JSF 2.0 Bean Validation and Dependency Injection

Data validation is such a common functionality in different tiers of Java applications that JSR 303 - bean validation, part of Java EE 6, provides a mechanism to define data validation constraints in a way that is independent of the application tier. This JSR allows you to specify data-validation constraints using annotations.

You can place these annotations on any field, method or class that follows the JavaBean naming convention. You can either use standard annotations (defined in the javax.validation.constraints package) or write your own custom annotations for specifying constraints.

The table below describes standard bean validation annotations:

Bean Validation Annotation	Constraint Imposed on the Annotated Element
@NotNull	Cannot be null
@Min	Must be a number whose value must be higher or equal to the specified minimum
@Max	Must be a number whose value must be lower or equal to the specified maximum
@Size	Must be between specified minimum and maximum limits
@Pattern	Must match the specified Java regular expression

The new release of JavaServer Faces, JSF 2.0, provides built-in support for bean validation if the server runtime (such as Java EE 6) requires it. You can also use it with Hibernate Validator (the reference implementation of JSR 303) in an environment where a Java EE 6 server may not be present.

Managed bean properties are mapped to UIInput components on the form; so you can place the standard validation constraints on them. The JSF implementation can apply the validation constraints on the component's values and capture any error message as FacesMessage, so that you can display them using h:messages or h:message.

As an example, suppose you used a JSF 2.0 custom component to create the registration view for a simple online quiz application. (Refer to JSF 2.0: Creating Composite Components for details on how you would do this.) To learn how to use bean validation, you will remodel the RegistrationBean from the online quiz application's registration view to include validation constraints on the property fields as shown below:

@ManagedBean
@RequestScoped
public class RegisterBean2 {
    @Size(min = 1, message = "Please enter the Email")
    @Pattern(regexp = "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+", message = "Email format is invalid.")
    private String email;
   
    @Size(min = 1, message = "Please enter a Username")
    private String userName;

    @Size(min = 1, max = 10, message = "Password is mandatory and cannot contain more than 10 characters")
    private String password;

    @Size(min = 1, message = "Enter password in Confirm Password field")
private String confirmPassword;

    @NotNull(message = "Please enter Date of birth")
    private Date dob;

   //... no other change required
}

You can impose the mandatory constraint using the @NotNull annotation, as in the case of the dob field. For the email, username and password fields, you cannot use @NotNull as the default values for these would be an empty string and not null. Hence, no validation error will be generated if @NotNull is used. Instead, you can use @Size and specify the minimum boundary as 1. In addition, every constraint annotation has a message element that accepts a string. Its value will be used to build an error message that will be translated into FacesMessage and displayed in the response view using h:messages or h:message.

Now, you can modify the composite component register.xhtml. You can remove the mandatory field validation (done using required="true") because you have imposed this constraint on the managed bean properties. Similarly, you can also remove the <f:validateRegex> tag as shown below:

<h:outputText value="#{cc.attrs.emailPrompt}"/>
<h:inputText id="email"  value="#{cc.attrs.managedBean.email}" >
<!--  
<f:validateRegex pattern="[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9]+"/> 
-->
</h:inputText>

You can now test the bean validation support. Figure 1 shows a sample output from submitting the form without entering any values.

JSF 2 also provides a <f:validateBean> tag that allows you to use validation groups. A validation group defines a subset of constraints; every constraint belongs to one or more groups. You can specify the validation group(s) to be considered during the validation of a component by using the validationGroups attribute as shown below:

<h:inputText value="#{bean.prop1}"> 

<f:validateBean validationGroups="com.demo.validation.groups.Group1"/> 
</h:inputText>

Page 1 of 2



This article was originally published on May 4, 2010