Introduction to JSF Core Tags Library

1) Introduction

This article introduces about the various Core Tags that are available in JSF. Tags represent some set of Actions that will be executed in the Server. This article assumes the reader to have a fair bit of knowlege in Java Server Faces. If not, then they can visit the Introductory Article in JSF in javabeat. For more information and resources about Java Server Faces, readers can also Jsf Articles Page visit here. This article will start off with the Major Classification of Core JSF Tags and then will explain in depth about the various different types of Tags that are available in each category. Wherever and whenever possible, Code Snippets are given to make the understanding of the Tags much clearer.

2) Core Tag Library

The Core Tags that are available in Java Server Faces are categorized as follows. Here the categorization is given based on the Functionality of the Tags. They are,

• Validator Tags
• Convertor Tags
• Listener Tags
• View Tags
• Select Tags
• Facet Tag
• Miscellaneous Tags

Following sections explains the various above mentioned Tags in greater detail.

3) Validator Tags

3.1) Introduction

In JSF, Data from the Clients, usually Browser, has to be validated before being processed by the Server Web Application. JSF has a number of Built-in Validations and also it comes with a Powerful Validation Framework for plugging-in Custom Validators. Bindings between JSF UI Components and Validation Logic can be done with ease with the help of JSF Core Tags. Four JSF Core Tags are available for doing Validation on the JSF UI Components. They are,

• Validate Length Tag
• Validate Long Range Tag
• Validate Double Range Tag
• Validator Tag

Let us see the various Validation Tags in greater detail.

3.2) Validate Length Tag

Validation pertaining to Data between Boundaries is a normal requirement for almost any kind of Web Application. For example, a common case includes "Password must be of [8-16] characters length". Validation Length Tag as identified by <f:validateLength> is used to specify the maximum and the minimum characters, a JSF UI Component can accept.

Following is the syntax definition of the Validate Length Tag,

					
<f:validateLength minimum = "minRange" maximum = "maxRange">
</f:validateLength>
					

In the above syntax, the value for the minimum and the maximum attributes must be numbers, which tells the Boundary Range allowed for a particular UI Component. For example, if a number of characters allowed for a username Text Component must be greater than 10 and less than 15, then we can have the following code which will achieves this,

					
<h:inputText value = "#{UserBean.userName}" id = "userNameTextField" required="true">
    <f:validateLength minimum = "10" maximum = "15"/>
</h:inputText>
					

In the above code, UserBean refers to a Managed Bean being defined and declared in the web.xml file and userName is the property of the UserBean class. The attribute 'id' of the <h:inputText> specifies the identifier of the Text Field UI Component and it must be unique among the other Components in the Form.

3.3) Validate Long Range Tag

This Tag is used to do Validations on JSF UI Components whose value is expected to fall between certain integer (long) values. Common cases will be restricting the age of a user between 1 and 40. The Validate Long Range Tag is identified by <f:validateLongRange> tag.

Following is the syntax definition of the Validate Long Range Tag,

					
<f:validateLongRange minimum = "minLongValue" maximum = "maxLongValue">
</f:validateLongRange>
					

In the above syntax, the 'minimum' and the 'maximum' attributes of Validate Long Range specifies the minimum and the maximum of the long value. Assuming that the birth-date of an Year Text-Field UI Component must fall between 1960 and 1985, then we can have the following code to achieve this goal,

					
<h:inputText value = "#{UserBean.birthYear}" id = "birthYearTF" required = "true">
    <f:validateLongRange minimum = "10" maximum = "15"/>
</h:inputText>
					

3.4) Validate Double Range Tag

This is the same the Validate Long Range Tag except that it operates on floating Data rather than Integer Data. UI Components that accepts floating values can use this Tag to perform Range Validations. The syntax for the following Tag is given by,

					
<f:validateDoubleRange minimum = "minDoubleValue" maximum = "maxDoubleValue">
</f:validateDoubleRange>
					

In the above syntax declaration, the 'minimum' and the 'maximum' attributes refer to the lower and the upper range of double value, a JSF UI Component can accept. For example, the following example restrict the Text UI Component to have values between 1000.00 and 100000.00.

					
<h:inputText value = "#{UserBean.amount}" id = "amountTextField" required = "true">
    <f:validateDoubleRange minimum = "1000.00" maximum = "100000.00"/>
</h:inputText>
					

3.5) Validator Tag

For performing Customized Validations on UI Components, one can prefer using this Validator Tag. Examples may include validating whether the entered email-id is in the appropriate format (username@domain.com) or whether the stock symbol is available in the database. The following is the syntax for the Validator Tag.

					
<f:validator validatorId = "IdForValidator">
</f:validator>
					

In the above syntax, the value for the 'validatorId' attribute refers to a name which must be previously defined in the web.xml file. For example, if we want to do a Phone-Number Validation for a Text Component, then we would have written a class called PhoneNumberValidator which implements the javax.faces.validator.Validator interface and then overriding the Validator.validate() method. Following is the how the Class may looks like,

PhoneNumberValidator.java

					
package myvalidators;

import javax.faces.validator.*;

public class PhoneNumberValidator implements Validator{

    public PhoneNumberValidator() {
    }

    public void validate(FacesContext context, UIComponent component, Object value) 
        throws ValidatorException {
        String strValue = (String)value;
        if (strValue.length() != 10){
            throwException("Number of phone digits must be 10");
        }
    }
}
					

Then, this Customized Validator Component must be registered to the Web Application by making the following entry in the faces-config.xml file.

faces-config.xml

					
<webapp>
    <validator>
        <validator-id>PhoneNumberValidator</validator-id>
        <validator-class>myvalidators.PhoneNumberValidator</validator-class>
    </validator>
</web-app>
					

Then the defined Validator Id in the faces-config.xml file, in the form of <validator-id> has to be referenced in UI Component like this,

					
<h:inputText value = "#{UserBean.phoneNumber}" id = "phoneNumberTF" required="true">
    <f:validator validatorId = "PhoneNumberValidator"/>
</h:inputText>