In this article, I would like to demonstrate how to integrate Spring MVC, Spring bean validation framework and hibernate validator using annotations. The Hibernate Validator project is implementation of JSR 303 – Bean Validation standard, which defines a metadata model and API for JavaBean validation. For the the purpose of this example, I used Spring Framework v3.0.5 and Hibernate Validator v4.1.0.
What I like about Spring + Hibernate validation, is that this combination eliminates the need to use validator classes in controllers for bean validation. In other words, less code, less classes, everything looks much cleaner.
I am not going to talk about how to build web application from scratch using Spring MVC. I assume that you already have something working in place. I am just going to show the important bits needed, in order to plug hibernate validation in to your code:
1. Define two following beans in your application context XML in your WEB-INF directory:
[xml]
<bean id="validator"
class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/>
[/xml]
The basic configuration above will trigger JSR-303 to initialize using its default bootstrap mechanism. A JSR-303 provider, such as Hibernate Validator, is expected to be present in the classpath and will be detected automatically.
[xml]
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename" value="/WEB-INF/message-resources.bundle" />
</bean>
[/xml]
The bean above knows how to access resource bundles using specified basenames.
2. Create resource bundle (in this example it is “message-resources.bundle”) under WEB-INF. The resource bundle is where you should define your validation messages that the end user sees if his form submission fails validation. Please note that the bundle does not have to be at the root of WEB-INF, it can be placed also in a sub-directory of WEB-INF. The format for validation messages in your bundle should be as follows:
[java]Annotation.bean-variable-name.bean-propery=validation error message.[/java]
For example:
[java]
NotBlank.someFormName.name=Name must not be blank,
Size.someFormName.name=Name must be less than or equal to {1} characters.
NotBlank.someFormName.street=Street name should not be blank. Please enter a value
NotEmpty.someFormName.selectedItem=Item selection is required
[/java]
The example above describes four different validation messages for different validation rules. In case of a particular validation rule disobeyed, its respective validation message will be found based on the validation annotation, bean name and bean property name.
3. In your controller, in the method that validates bean from the POST request, annotate your bean with annotation @Valid. For example:
[java]
@RequestMapping(value = "/update.html", method = RequestMethod.POST)
public String update ( @ModelAttribute("someFormName")
@Valid SomeForm someFormName,
BindingResult result,
Model model)
{
if(result.hasErrors()) {
// Return view name
}
// Do stuff
// Return view name
}
[/java]
The @Valid annotation is part of the standard JSR 303 – Bean Validation API, and is not a Spring-specific construct. The Hibernate Validator instance invoked when a @Valid method argument is encountered.
Very important: your bean variable name in your controller method (in this case its “someFormName“) must match the bean variable name in your validation message resource bundle.
4. Annotate your bean member variables with annotations that tell Hibernate Validator what should be validated and what are the validation rules:
[java]
public final class SomeForm {
@NotBlank
@Size(min=0,max=20)
private String name;
@NotBlank
private String street;
@NotEmpty
private String selectedItem;
// Getters
// Setters
}
[/java]
As you can see from the above bean, the three fields that should be validated are annotated with @NotBlank, @NotEmpty and @Size. The validation rules are simple: the name property must not be blank nor longer than 20 characters, street property must not be blank, while selectedItem must not be empty.
By the way, you can have more complicated validation rules in place using annotations. It is possible to use expressions which decide whether validation rules should fire. Consider the following, which validate an email field:
[java]
@Email(applyIf="email is not blank")
@NotBlank
private String email;
[/java]
You don’t want to display invalid email format error message when the filed is blank. Therefore that above expression in @Email annotation will have the rule fired only when the property is not blank. Expression can be especially very convenient when validating password fields:
[java]
@NotBlank
private String password;
@NotBlank(applyIf = "password is not blank")
@Expression(value = "confirmedPassword= password", applyIf = "password is not blank")
private String confirmedPassword;
[/java]
Validation rules for confirmedPassword property will fire only when password field will not be blank.
That’s it 
If any rule(s) are disobeyed, the BindingResult result object will be populated with appropriate error messages, loaded from your message bundle. The error messages then can be displayed in your JSP using Spring tag:
[xml]
<spring:hasBindErrors name="someFormName">
<c:forEach items="${errors.allErrors}" var="error">
<spring:message message="${error}"/>
</c:forEach>
</spring:hasBindErrors>
[/xml]
And that is it! Feel free to post a comment if you run into problems and I iwll try to help you the best I can