Spring REST Validation

[Michael Oberleitner]

Hello,

I need to validate a simple JSON-Object, which comes in the body of a HTTP-request.
This is the spring controller with the relevant methods. The addEmployee() method works fine, the updateEmployee() method only works fine when the JSON in the request is valid. When the JSON is not valid does not get called at all

package org.strupp.controller;

import java.util.List;
import java.util.Set;

import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.Valid;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.strupp.exception.NoSuchEmployeeException;
import org.strupp.model.Employee;
import org.strupp.model.Status;
import org.strupp.services.EmployeeServices;

@Controller
@RequestMapping("/employee")
public class EmployeeController {

	@Autowired
	EmployeeServices employeeServices;
	
	static final Logger logger = Logger.getLogger(EmployeeController.class);
	
	@RequestMapping(value = "/create", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody Status addEmployee(@Valid final @RequestBody Employee employee, BindingResult bindingResult) {
		if (bindingResult.hasErrors()) {
			Set<ConstraintViolation<Employee>> constraintViolations = validateInput(employee);
			throw new ConstraintViolationException(constraintViolations);
	    } else {
			try {
				employeeServices.addEntity(employee);
				return new Status(1, "Employee added Successfully !");
			} catch (Exception e) {
				 e.printStackTrace();
				return new Status(0, e.toString());
			}
	    }
	}
	
	@RequestMapping(value = "/update/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody Status updateEmployee(@Valid final @RequestBody Employee employee, @PathVariable("id") long id,
			BindingResult bindingResult) {
		if (bindingResult.hasErrors()) {
			Set<ConstraintViolation<Employee>> constraintViolations = validateInput(employee);
			throw new ConstraintViolationException(constraintViolations);
	    } else {
			try {
				employee.setId(id);
				employeeServices.updateEmployee(employee);
				return new Status(1, "Employee updated !");
			} catch (Exception e) {
				 e.printStackTrace();
				return new Status(0, e.toString());
			}
	    }
	}
}

This is the dto-object:

package org.strupp.model;

import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.annotate.JsonManagedReference;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotBlank;

import org.strupp.serializer.CarSerializer;

@Entity
@Table(name = "employee")
@JsonIgnoreProperties({ /*"cars",*/ "hibernateLazyInitializer", "handler" })
public class Employee implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue
	@Column(name = "id")
	private long id;

	@Column(name = "first_name")
	@NotBlank(message = "firstName field can not be blank")
        @Length(max = 45, message = "firstName should not be more than 45 characters")
	private String firstName;

	@Column(name = "last_name")
	@NotBlank(message = "lastName field can not be blank")
	@Length(max = 45, message = "lastName should not be more than 45 characters")
	private String lastName;

	@Column(name = "email")
	@Length(max = 45, message = "email should not be more than 10 characters")
	private String email;

	@Column(name = "phone")
	@Length(max = 45, message = "phone should not be more than 10 characters")
	private String phone;
	
	@OneToMany(fetch = FetchType.EAGER, cascade = {CascadeType.PERSIST, CascadeType.MERGE}, mappedBy = "employee")
	@JsonManagedReference
	@JsonSerialize(using = CarSerializer.class)
//	@JsonDeserialize(using = CarDeserializer.class)
	private List<Car> cars = new LinkedList<Car>();
	
	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public List<Car> getCars() {
		return cars;
	}

	public void setCars(List<Car> cars) {
		this.cars = cars;
	}
}

That's how I do the request:


The 'content type'-header is set to application/json in both requests, the only difference in both calls is the URL and the http-method. When i cut the firstname to a length < 45 also updateEmployee() works fine.

I hope someone can help me with this,

thanks in advance,
Michael

[Stephan van Hulst]

So what's the response you get from the server after sending the request?

[Michael Oberleitner]

The response is 400 Bad Request

[Stephan van Hulst]

The binding result must come immediately after the validated parameter.

[Michael Oberleitner]

Thanks you very much Stephan!
I did not know this.