<mystore:formatValidator
formatPatterns="9999999999999999|9999 9999 9999 9999|9999-9999-9999-9999"/>
|
Java Platform, Enterprise Edition (Java EE) 8 The Java EE Tutorial |
| Previous | Next | Contents |
If the standard validators or Bean Validation don’t perform the validation checking you need, you can create a custom validator to validate user input. As explained in Validation Model, there are two ways to implement validation code.
Implement a managed bean method that performs the validation.
Provide an implementation of the javax.faces.validator.Validator
interface to perform the validation.
Writing a Method to Perform Validation
explains how to implement a managed bean method to perform validation.
The rest of this section explains how to implement the Validator
interface.
If you choose to implement the Validator interface and you want to
allow the page author to configure the validator’s attributes from the
page, you also must specify a custom tag for registering the validator
on a component.
If you prefer to configure the attributes in the Validator
implementation, you can forgo specifying a custom tag and instead let
the page author register the validator on a component using the
f:validator tag, as described in Using a Custom
Validator.
You can also create a managed bean property that accepts and returns the
Validator implementation you create, as described in
Writing Properties Bound to Converters,
Listeners, or Validators. You can use the f:validator tag’s binding
attribute to bind the Validator implementation to the managed bean
property.
Usually, you will want to display an error message when data fails validation. You need to store these error messages in a resource bundle.
After creating the resource bundle, you have two ways to make the
messages available to the application. You can queue the error messages
onto the FacesContext programmatically, or you can register the error
messages in the application configuration resource file, as explained in
Registering Application Messages.
For example, an e-commerce application might use a general-purpose
custom validator called FormatValidator.java to validate input data
against a format pattern that is specified in the custom validator tag.
This validator would be used with a Credit Card Number field on a
Facelets page. Here is the custom validator tag:
<mystore:formatValidator
formatPatterns="9999999999999999|9999 9999 9999 9999|9999-9999-9999-9999"/>
According to this validator, the data entered in the field must be one of the following:
A 16-digit number with no spaces
A 16-digit number with a space between every four digits
A 16-digit number with hyphens between every four digits
The f:validateRegex tag makes a custom validator unnecessary in this
situation. However, the rest of this section describes how this
validator would be implemented and how to specify a custom tag so that
the page author could register the validator on a component.
A Validator implementation must contain a constructor, a set of
accessor methods for any attributes on the tag, and a validate method,
which overrides the validate method of the Validator interface.
The hypothetical FormatValidator class also defines accessor methods
for setting the formatPatterns attribute, which specifies the
acceptable format patterns for input into the fields. The setter method
calls the parseFormatPatterns method, which separates the components
of the pattern string into a string array, formatPatternsList.
public String getFormatPatterns() {
return (this.formatPatterns);
}
public void setFormatPatterns(String formatPatterns) {
this.formatPatterns = formatPatterns;
parseFormatPatterns();
}
In addition to defining accessor methods for the attributes, the class
overrides the validate method of the Validator interface. This
method validates the input and also accesses the custom error messages
to be displayed when the String is invalid.
The validate method performs the actual validation of the data. It
takes the FacesContext instance, the component whose data needs to be
validated, and the value that needs to be validated. A validator can
validate only data of a component that implements
javax.faces.component.EditableValueHolder.
Here is an implementation of the validate method:
@FacesValidator
public class FormatValidator implements Validator, StateHolder {
...
public void validate(FacesContext context, UIComponent component,
Object toValidate) {
boolean valid = false;
String value = null;
if ((context == null) || (component == null)) {
throw new NullPointerException();
}
if (!(component instanceof UIInput)) {
return;
}
if ( null == formatPatternsList || null == toValidate) {
return;
}
value = toValidate.toString();
// validate the value against the list of valid patterns.
Iterator patternIt = formatPatternsList.iterator();
while (patternIt.hasNext()) {
valid = isFormatValid(
((String)patternIt.next()), value);
if (valid) {
break;
}
}
if ( !valid ) {
FacesMessage errMsg =
new FacesMessage(FORMAT_INVALID_MESSAGE_ID);
FacesContext.getCurrentInstance().addMessage(null, errMsg);
throw new ValidatorException(errMsg);
}
}
}
The @FacesValidator annotation registers the FormatValidator class
as a validator with the JavaServer Faces implementation. The validate
method gets the local value of the component and converts it to a
String. It then iterates over the formatPatternsList list, which is
the list of acceptable patterns that was parsed from the
formatPatterns attribute of the custom validator tag.
While iterating over the list, this method checks the pattern of the
component’s local value against the patterns in the list. If the pattern
of the local value does not match any pattern in the list, this method
generates an error message. It then creates a
javax.faces.application.FacesMessage and queues it on the
FacesContext for display, using a String that represents the key in
the Properties file:
public static final String FORMAT_INVALID_MESSAGE_ID =
"FormatInvalid";
}
Finally, the method passes the message to the constructor of
javax.faces.validator.ValidatorException.
When the error message is displayed, the format pattern will be
substituted for the {0} in the error message, which, in English, is as
follows:
Input must match one of the following patterns: {0}
You may wish to save and restore state for your validator, although
state saving is not usually necessary. To do so, you will need to
implement the StateHolder interface as well as the Validator
interface. To implement StateHolder, you would need to implement its
four methods: saveState(FacesContext),
restoreState(FacesContext, Object), isTransient, and
setTransient(boolean). See Saving and
Restoring State for more information.
If you implemented a Validator interface rather than implementing a
managed bean method that performs the validation, you need to do one of
the following.
Allow the page author to specify the Validator implementation to use
with the f:validator tag. In this case, the Validator implementation
must define its own properties. Using a Custom Validator
explains how to use the f:validator tag.
Specify a custom tag that provides attributes for configuring the properties of the validator from the page.
To create a custom tag, you need to add the tag to the tag library
descriptor for the application, bookstore.taglib.xml:
<tag>
<tag-name>validator</tag-name>
<validator>
<validator-id>formatValidator</validator-id>
<validator-class>
dukesbookstore.validators.FormatValidator
</validator-class>
</validator>
</tag>
The tag-name element defines the name of the tag as it must be used in
a Facelets page. The validator-id element identifies the custom
validator. The validator-class element wires the custom tag to its
implementation class.
Using a Custom Validator explains how to use the custom validator tag on the page.
To register a custom validator on a component, you must do one of the following.
Nest the validator’s custom tag inside the tag of the component whose value you want to be validated.
Nest the standard f:validator tag within the tag of the component
and reference the custom Validator implementation from the
f:validator tag.
Here is a hypothetical custom formatValidator tag for the Credit Card
Number field, nested within the h:inputText tag:
<h:inputText id="ccno" size="19"
...
required="true">
<mystore:formatValidator
formatPatterns="9999999999999999|9999 9999 9999 9999|9999-9999-9999-9999"/>
</h:inputText>
<h:message styleClass="validationMessage" for="ccno"/>
This tag validates the input of the ccno field against the patterns
defined by the page author in the formatPatterns attribute.
You can use the same custom validator for any similar component by simply nesting the custom validator tag within the component tag.
If the application developer who created the custom validator prefers to
configure the attributes in the Validator implementation rather than
allow the page author to configure the attributes from the page, the
developer will not create a custom tag for use with the validator.
In this case, the page author must nest the f:validator tag inside the
tag of the component whose data needs to be validated. Then the page
author needs to do one of the following.
Set the f:validator tag’s validatorId attribute to the ID of the
validator that is defined in the application configuration resource
file.
Bind the custom Validator implementation to a managed bean property
using the f:validator tag’s binding attribute, as described in
Binding Converters, Listeners, and
Validators to Managed Bean Properties.
The following tag registers a hypothetical validator on a component
using an f:validator tag and references the ID of the validator:
<h:inputText id="name" value="#{CustomerBean.name}"
size="10" ...>
<f:validator validatorId="customValidator" />
...
</h:inputText>
| Previous | Next | Contents |
Copyright © 2017, Oracle and/or its affiliates. All rights reserved.