web application – Enavigo

How much is a brand worth to a company? For most small companies it means virtually everything. They are one and all with the brand. Bigger companies often pour massive amounts into building and maintaining brands. According to David Ogilvy, the father of modern advertising, such brand positioning makes or breaks the brand. Something breaks, though, when it comes to mobile.

Companies and organizations that make such huge investments in their brand suddenly realize their website, often times their core offering, looks bad or does not work on mobile devices. In a world where budgets are almost always tight, they look to do something out of nothing to address this problem. They want to be available to the growing smartphones and tablet-using masses. They need something.

In my charge to regain my coding skills, I am using Spring MVC and trying to run it on Google's App Engine.

As with any web application, I have a form which I was looking to validate. Spring appears to be very high on its integration of Hibernate's implementation of a budding Java standard, JSR-303, In essence that means annotating a POJO bean file and then having your Spring MVC Controller (@Controller is the annotation) use another annotation (@Valid) to trigger validation. If errors are found, the form is returned with error messages. Pretty awesome. Yet JSR-303 has a rather big omission: if you have to fields in a form that must be identical – as in the case of password a password confirmation field, you need to write custom code. Luckily, that capability is covered by *the other* Spring-related validation framework – The Spring Modules project's Validation library.

Configuring Spring Modules' validation is covered insanely well by Willie Wheeler. Spring Modules Validation (SMV hereafter) has the ability to compare fields to each other as a validation condition and also apply a validation rule based on prior validation success (look here for table 17.11). Very very cool powerful stuff.

Where his article needs a bit of help is in how to set up custom error messages. See, SMV detects a validation error, it looks to create an error message that your Spring MVC form will display to the user. The default error messages are intentionally lacking, as you *are* expected to provide your own version for an error. And while the Wheeler article talks about how to set the errors up in a Properties file, he does not (nor is he expected – again thank you) cover all possible validation error codes that are necessary for you to define the error messages. This is why I am writing this post.

So, your custom error message properties file will consist of lines like the following:

SimpleClassName.propertyBeingValidated[validationRuleViolated]=your custom error message

So if you had a class called ApplicationUser with a field called email, your annotated class code will look this:

@Email private String email;

And your error message properties file will have a line like:

ApplicationUser.email[email]=Please enter a valid email address

You need to ensure that your class name (no package needed) is correctly capitalized. What's not clear – and drove me nuts, is what exactly are the error codes you put within the brackets – for example – [email].

Thanks to this incredibly useful post on the SpringFramework discussion boards, the error codes are based on default strings that are embedded in each one of the validation classes inside the org.springmodules.validation.bean.rule package.

To spare you digging through the source, here are the validation rules and the default error code strings associated with them:

Validation Rule	Error Code	Description
`@NotNull`	`[not.null]`	This rule validates that the validated value is not null.
`@NotBlank`	`[not.blank]`	This rule checks that a string value is not blank (that is, it holds some characters).
`@InTheFuture`	`[in.future]`	This validation rule checks that the validated date/calendar/instant occurs in the future (relative to the time of validation).
`@InThePast`	`[in.past]`	This validation rule checks that the validated date/calendar/instant occurred in the past (relative to the time of validation).Attributes are `value` that"Specifies the condition expression " and optionally, `expressionScope`. Defines the evaluation scope of the condition expression. global will define the validated object as the scope, while property will define the property value as the scope. Using the property scope enables the definition of conditions that apply directly on the property value (e.g. "length > 5"). The global scope enables the definition of conditions that apply on other properties of the validated object (e.g. "equals some_other_property")
`@Email`	`[email]`	This rule validates that a string value holds a valid email address.
`@Expression`	`[expression]`	This annotation represents an expression based validation rule. See Table 17.11
`@Length`	`[length]`	This rule checks that the range of a string's length is within specific bounds.See Table 17.13 for extra attributes
`@MaxLength`	`[max.length]`	This rule checks that the range of a string's length is less than or equals a specific upper bound. Must have a `max` attribute that "Specifies the maximum length the string value can have"
`@MinLength`	`[min.length]`	This rule checks that a string's length is greater than or equals a specific lower bound. Must have a `value` attribute that "Specifies the minimum length the string value can have"
`@NotEmpty`	`[not.empty]`	This rule checks that a collection/array is not empty (that is, it holds at least one element).
`@size`	`[size]`	This rule checks that the size of a collection/array is within specific bounds. See Table 17.16. Essentially, `min` and `max` attributes
`@MinSize`	`[min.size]`	This rule checks that the size of a collection/array is greater than or equals a specific lower bound. Must have a `value` attribute that "Specifies the minimum size of the collection or array ".
`@MaxSize`	`[max.size]`	This rule checks that a `java.lang.Comparable` value is within a specific range. Must have a `value` attribute that "Specifies the maximum size of the collection or array".
`@Range`	`[range]`	This rule checks that the size of a collection/array is less than or equals a specific bound. Must define either a `min` or a `max` attributes or both. Specify the lower and upper bounds of the range, respectively.
`@Min`	`[range]`	This rule checks that a java.lang.Comparable value is greater than or equals a specific lower bound. Must define a `value` attribute that "Specifies the lower bound of the range"
`@Max`	`[range]`	This rule checks that a java.lang.Comparable value is less than or equals a specific upper bound. Must define a `value` attribute that "Specifies the upper bound of the range"
`@RegExp`	`[regexp]`	This rule checks that a string value matches a specific regular expression. Must define a `value` attribute that "Specifies the regular expression"
`@Expressions`	`[expression]`	This annotation enables defining multiple `@Expression` annotations on a property.
`@ConditionRef`	`[spring.condition]`	This rule uses a condition that is defined in the application context to perform the validation check. Must define a `value` attribute that "Specifies the name of the condition bean as defined in the application context."

Hope this is of help to others.