Sealyu

Firstly you need to configure the Validator Factory which is the factory to get Validator instances. To do so, the support provides the class DefaultValidatorFactory in the package org.springmodules.validation.commons

You need to specify with the property validationConfigLocations the file containing the Commons Validator rules and the file containing the validation rules specific to the application.

The following code shows how to configure this factory.

<bean id="validatorFactory"

class="org.springmodules.validation.commons.DefaultValidatorFactory">

<property name="validationConfigLocations">

<list>

<value>/WEB-INF/validator-rules.xml</value>

<value>/WEB-INF/validation.xml</value>

</list>

</property>

</bean>

The file validation-rules.xml must contain Commons Validator elements based on classes provided by the support of this framework in Spring Modules.

For example, the configuration of the entities "required" and "requiredif" must be now in the validation-rules.xml file.

<validator name="required"

classname="org.springmodules.validation.commons.FieldChecks"

method="validateRequired"

methodParams="java.lang.Object,

org.apache.commons.validator.ValidatorAction,

org.apache.commons.validator.Field,

org.springframework.validation.Errors"

msg="errors.required">



<javascript><![CDATA[

(...)

]]></javascript>

</validator>



<validator name="requiredif"

classname="org.springmodules.validation.commons.FieldChecks"

method="validateRequiredIf"

methodParams="java.lang.Object,

org.apache.commons.validator.ValidatorAction,

org.apache.commons.validator.Field,

org.springframework.validation.Errors,

org.apache.commons.validator.Validator"

msg="errors.required">

</validator>

The validation sample of the distribution provides a complete validation-rules.xml based on the classes of the support.

You must note that the support of validwhen is not provided at the moment in the support. However, some codes are provides in JIRA. For more informations, see the issues MOD-38 and MOD-49.

Then you need to configure the Validator itself basing the previous Validator Factory. It corresponds to an adapter in order to hide Commons Validator behind a Spring Validator.

The following code shows how to configure this validator.

<bean id="beanValidator" class="org.springmodules.validation.commons.DefaultBeanValidator">

<property name="validatorFactory" ref="validatorFactory"/>

</bean>

Spring MVC provides the implementation SimpleFormController of the interface Controller in order to process HTML forms. It allows a validation of informations processing by the controller by using the property validator of the controller. In the case of Commons Validator, this property must be set with the bean beanValidator previously configured.

The following code shows how to configure a controller which validates a form on the server side using the support of Commons Validator.

<bean id="myFormController" class="org.springmodules.sample.MyFormController">

(...)

<property name="validator" ref="beanValidator"/>

<property name="commandName" value="myForm"/>

<property name="commandClass" value="org.springmodules.sample.MyForm"/>

(...)

</bean>

The beanValidator bean uses the value of the property commandClass of the controller to select the name of the form tag in the validation.xml file. The configuration is not based on the commandName property. For example, with the class name org.springmodules.sample.MyForm, Commons Validator must contain a form tag with myForm as value of the name property. The following code shows the contents of this file.

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE form-validation PUBLIC

"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1//EN"

"http://jakarta.apache.org/commons/dtds/validator_1_1.dtd">



<form-validation>

<formset>

<form name="myForm">

<field property="field1" depends="required">

<arg0 key="error.field1" />

</field>

<field property="field2" depends="email">

<arg0 key="error.field2" />

</field>

</form>

</formset>

</form-validation>

Partial validation support enables partial validation of beans where not all properties are validated but only selected ones.

Commons validator enables partial validation by specifying the page attribute for each field in the form configuration:

<form name="personDataWizard">

<field property="firstName" depends="required" page="0">

<arg0 key="person.first.name" />

</field>

<field property="lastName" depends="required" page="0">

<arg0 key="person.last.name" />

</field>

<field property="email" depends="required,email" page="0">

<arg0 key="person.email" />

</field>

<field property="password" depends="required" page="1">

<arg0 key="person.password" />

</field>

<field property="verifyPassword" depends="validwhen" page="1">

<arg0 key="person.password.not.matching" />

<var>

<var-name>test</var-name>

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

</var>

</field>

</form>

The org.springmodules.validation.commons.ConfigurablePageBeanValidator and org.springmodules.validation.commons.DefaultPageBeanValidator classes support partial validation by setting their page property. The value of this property will be matched with the page attribute in the form configuration, and only the fields with the appropriate page configured will be validated.

The following is an example of a partial validation support usage within a wizard controller:

<bean id="personWizardController" class="PersonWizardController">

<property name="pages">

<list>

<value>personPage0</value>

<value>personPage1</value>

</list>

</property>

<property name="allowDirtyForward" value="false"/>

<property name="validators">

<list>

<ref bean="pageValidator0"/>

<ref bean="pageValidator1"/>

</list>

</property>

<property name="commandName" value="person"/>

<property name="commandClass" value="PersonData"/>

</bean>



<bean id="pageValidator0" class="ConfigurablePageBeanValidator" parent="pageValidator">

<property name="page" value="0"/>

</bean>



<bean id="pageValidator1" class="ConfigurablePageBeanValidator" parent="pageValidator">

<property name="page" value="1"/>

</bean>



<bean id="pageValidator" abstract="true">

<property name="formName" value="personDataWizard"/>

<property name="validatorFactory" ref="validatorFactory"/>

</bean>



...

The controller will look like this:

public class PersonWizardController extends AbstractWizardFormController {



...



protected void validatePage(Object command, Errors errors, int page) {

Validator[] validators = getValidators();

for (int i=0; i<validators.length; i++) {

Validator validator = validators[i];

if (validator instanceof PageAware) {

if (((PageAware)validator).getPage() == page) {

validator.validate(command, errors);

}

}

}

}

}

The support of Commons Validator in Spring Modules provides too the possibility to use a client side validation. It provides a dedicated taglib to generate the validation javascript code. To use this taglib, we firstly need to declare it at the beginnig of JSP files as following.

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

You need then to include the generated javascript code in the JSP file as following by using the javascript tag.

<validator:javascript formName="account"

staticJavascript="false" xhtml="true" cdata="false"/>

At last, you need to set the onSubmit attribute on the form tag in order to trigger the validation on the submission of the form.

<form method="post" action="(...)" onsubmit="return validateMyForm(this)">

Valang (Va-lidation Lang-uage), provides a simple and intuitive way for creating spring validators. It was initially create with three goals in mind:

Valang is built upon two major constructs - The valang expression language and valang validators. The former is a generic boolean expression language that enables expressing boolean rule in a "natural language"-like fashion. The later is a concrete implementation of the Spring Validator interface that is built around the expression language.

Before going into details, lets first have a look at a small example, just to have an idea of what valang is and how it can be used. For this example, we'll assume a Person class with two properties - firstName and lastName. In addition, there are two main validation rules that need to be applied:

One way of applying these validation rules (and currently the most common one) is to implement the Validator interface specifically for the Person class:

public class PersonValidator implements Validator {



public boolean supports(Class aClass) {

return Person.class.equals(aClass);

}



public void validate(Object person, Errors errors) {

String firstName = ((Person)person).getFirstNam();

String lastName = ((Person)person).getLastName();

if (firstName == null || firstName.length() >= 30) {

errors.reject("first_name_length", new Object[] { new Integer(30) },

"First name must be shorter than 30");

}

if (lastName == null || lastName.length() >= 50) {

errors.reject("last_name_length", new Object[] { new Integer(50) },

"Last name must be shorter than 50");

}

}

}

While this is a perfectly valid approach, it has its downsides. First, it is quite verbose and time consuming - quite a lot of code to write just for two very simple validation rules. Second, it required an additional class which clutters the code (in case it is an inner-class) or the design - just imagine having a validator class for each of the domain model objects in the application.

The following code snippet shows how to create a valang validator to apply the same rules as above:

<bean id="personValidator" class="org.springmodules.validation.valang.ValangValidator">

<property name="valang">

<value>

<![CDATA[

{ firstName : length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

]]>

</value>

</property>

</bean>

There are a few things to notice here. First, no new class is created - with valang, one can reuse a predefined validator class (as shown here). Second, This validator is not part of the java code, but put in the application context instead - In the above case, the ValangValidator is instantiated and can be injected to other objects in the system. Last but not least, The validation rules are defined using the valang expression language which is very simple and quick to define.

The following two sections will elaborate on the expression language and the use of the Valang validator in greater details.

{ <key> : <predicate_expression> : <message> [: <error_code> [: <args> ]] }

<expression> ::= <expression> ( ( "AND" | "OR" ) <expression> )+ | <predicate>

name > 0

age == 'some string'

<between_operator> ::= <left_side> BETWEEN <value> AND <value>

<not_between_operator> ::= <left_side> NOT BETWEEN <value> AND <value>

width between 10 and 90

length(name) between minLength and maxLength

<in_operator> ::= <left_side> IN <value> ( "," <value> )*

<not_in_operator> ::= <left_side> NOT IN <value> ( "," <value> )*

<special_in_operator> ::= <left_side> IN "@"<bean_property>

<special_not_in_operator> ::= <left_side> NOT IN "@"<bean_property>

size in 'S', 'M', 'L', 'XL'

size in @sizes

<not_operator> ::= "NOT" <expression>

'Bill', 'George', 'Junior'

0.70, 1, 2000, -3.14

[T<d], [2005-05-28]

<boolean> ::= ( "TRUE" | "YES" | "FALSE" | "NO" )

name, address, attributes

address.street

friends[1].name

enemies[0].address.city

specialFriends[bestFriend].name

function ::= <function_name> "(" <arg> [ "," <arg> ]* ")"

<arg> ::= <literal> | <bean_property> | <function>

length(?)

size(upper('test'))

upper(address.city)

2 - 3 + 5 = 4

(2 * (15 - 3) + ( 20 / 5 ) ) * -1

(22 / 7) - (22 div 7)

10 % 3

length(?) mod 4

{ <key> : <predicate_expression> : <message> [: <error_code> [: <args> ]] }

{ firstName : length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

<bean id="personValidator" class="org.springmodules.validation.valang.ValangValidator">

<property name="valang">

<value>

<![CDATA[

{ firstName : length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

]]>

</value>

</property>

</bean>

<bean id="personValidator" class="org.springmodules.validation.valang.ValangValidator">

<property name="customFunctions">

<map>

<entry key="doIt">

<value>org.springmodules.validation.valang.functions.DoItFunction</value>

</entry>

</map>

</property>

<property name="valang">

<value>

<![CDATA[

{ firstName : doIt(?) and length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

]]>

</value>

</property>

</bean>