Integrating Jakarta Validation with Spring using Spring Modules

This is the first in the never ending series of tutorials I will be posting because I'm getting pissed off at work at how open source technologies lack such useful resources.

NOTE: This tutorial is meant to be an addition to this one.

Before you begin.
At the time of writing of this tutorial the following versions were referred to:
Spring 2.0
Springmodules 0.7

Here are a few resources you may find useful, in addition to those, mentioned in this tutorial.
DefaultValidatorFactory (source code)
DefaultBeanValidator (source code)
AbstractBeanValidator (source code)
ConfigurableBeanValidator (source code)
MultiActionController (javadoc)
BindException (javadoc)
YouTube (music videos to ease the pain)

1. Configuring Validator Factory.
This is a simple and easy step of adding a ValidatorFactory bean to Spring applicationContext.xml. See the aforementioned documentation above for reference.

2. Validation Rules!
This step is also self explanatory since you're simply to download the provided validation-rules.xml and save it at the location you've specified in your ValidatorFactory bean.

3. Configure your Validator.
This is also pretty easy understand from the provided documentation.

4. Client side validation.
I'm going to swap two steps of client and server side validation since I found that order to be more intuitive to those who have never tried anything related to validation in their life.

So, really, what does the client side validation? Yup, you've guessed it, JavaScript that comes with the package. However, adding that javascript to your JSP page isn't as easy.

Import proper tag library.
To do so, simply add a declaration snippet to import the validation tags.

<%@ tglib uri="http://www.springmodules.org/tags/commons-validator" prefix="validator" %>

Add javaScript to the page.
To do so, use the newly imported validator tag to import the code:

<validator:javascript formName="account" staticJavascript="false" xhtml="true" cdata="false"/>

Enable validation of your form.
If you're using a simple <form> tag, then simply add

onsubmit="return validateMeaningfulNameForm(this)"

to your form tag declaration. If you're using Spring's <form:form> tag, I suggest externalizing all the code required for form submission into a function. I used property binding method, thus my function looked like this:

function formSubmit(){
alert("Submitting and validating the form data.");
document.meaningfulNameForm.actionMethod.value="submitForm";
validateMeaningfulNameForm(this);
}

Naming of your form is very important. You have two options in this.

Using DefaultBeanValidator.
This class provides automation of resolving your form's name. When using this validator, it is assumed that the name of the form is the same as the class name of the form's backing bean.

Example. Imagine I have a class org.mycompany.forms.Data which is meant to represent the data I get submitted through my form. (i.e. my Data class is the backing bean for my form) If you're using DefaultBeanValidator then your form's name MUST be data, due to the way this validator class resolves the form names.

Using ConfigurableBeanValidator.
In contrast, this class provides flexibility by allowing to configure the form's name it's validating through Spring's bean invocation. Simply create a validator bean for each form and you're off to the races!

Example. Imagine that I like to name my forms with meaningful names and have defined the form in the following manner:

<form id="meaningfulNameForm" name="meaningfulNameForm" onsubmit="return validateMeaningfulNameForm">

Thus I will create the following bean in my applicationContext.xml:

<bean id="meaningfulNameFormValidator" class="org.springmodules.commons.validator.ConfigurableBeanValidator">
<property name="formName" value="meaningfulNameForm" />
</bean>

I will then need to pass this bean to an appropriate controller for my form.

Defining validation rules for your form.
Now that we've decided on the naming of the forms, it's important to tell the validator what are the valid conditions that the data will be validated against.

Now this is the part where it gets all confusing. There are a bunch of pre-made validators that are readily defined in validation-rules.xml. A few of the most common ones are

• required - defines a field as a required field and verifies that the value of the field is not null and its length is not 0.
• validWhen - ensures that the expression, specified in the test parameter is true (explained further).

You can easily write your own validators if those that are available in the org.springmodules.validation.commons.FieldChecks class do not fit your constraints and add them to validation-rules.xml to use them. However, if you're satisfied with those that are already provided for you, check out the javadocs for the version you're using from their site. Each validator maps itself to an appropriate method within the aforementioned FieldChecks class and their functionality is explained in the javadoc.

The DTD provides a short overview of the different tags and fields that are available to the user to enable the validation of a particular form. (they are also rather intuitive) However, one particular tag that lacks any explanation is the <var> tag with two of its children, <var-name> and <var-value>. These are used together with such validators as validWhen to provide necessary variables for testing.

Example. When using validWhen validator, you need to provide a boolean expression to be verified. This is done through <var> tag:

<var>
<var-name>test</var-name>
<var-value>(*this* == password)</var-value>
</var>

This validator is expecting a boolean variable, named test, to be passed in with the value of the boolean expression in order to validate the form field.

The tutorial, mentioned at the beginning of the post shows a simple set up. One thing to note is the fact that you have to make sure that you're specifying the proper form name in the <form> tag.

5. Server side validation.
Ah, here comes another fun part. If you thought you're done, think again. Now that you've configured your client side to invoke validations, the errors are thrown around, (hopefully) logged somewhere and yet nothing is being done to fix this mess.

The online documentation covers the set up of the controller bean, in case you decide to go with the SimpleFormController implementation. However, in the world of dynamics we venture off to use AJAX in our web applications and thus decide to utilize the functionality of MultiActionController class. Its set up differs just a tad, however, from that of SimpleFormController.

<bean id="multiActionController" class="org.springframework.web.servlet.mvc.multiaction.MultiActionController">
<property name="validators" >
<list>
<ref bean="beanValidator" /> <!-- this is your validator bean, defined earlier -->
</list>
</property>
</bean>

The controller will throw a BindException which you may use to access such information as which field was not validated and why. This can be used by some custom controller to react accordingly or to simply display proper error messages to the user.