...
The most complex element on the page is the inputText text field. The maxlength attribute
specifies the maximum length of the field. The required attribute specifies that the field must
be filled out; the requiredMessage attribute provides the error message to be displayed if the
field is left empty. The title attribute provides the text to be used by screen readers for the
visually disabled. Finally, the value attribute contains an expression that will be provided by the
Hello managed bean.
The Submit commandButton element specifies the action as response, meaning that when the
button is clicked, the response.xhtml page is displayed.
6
Double-click the response.xhtml file to view it.
The response page appears. Even simpler than the greeting page, the response page contains a
graphic image, a header that displays the expression provided by the managed bean, and a
single button whose action element transfers you back to the index.xhtml page:
Facelets Hello Response
Hello, #{hello.name}!
7
8
Expand the Source Packages node, then the hello1 node.
Double-click the Hello.java file to view it.
The Hello class, called a managed bean class, provides getter and setter methods for the name
property used in the Facelets page expressions. By default, the expression language refers to the
class name, with the first letter in lowercase (hello.name).
package hello1;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
@ManagedBean
@RequestScoped
public class Hello {
private String name;
public Hello() {
}
public String getName() {
return name;
}
public void setName(String user_name) {
this.name = user_name;
}
}
9
Under the Web Pages node, expand the WEB-INF node and double-click the web.xml file to view
it.
The web.xml file contains several elements that are required for a Facelets application. All these
are created automatically when you use NetBeans IDE to create an application:
■ A context parameter specifying the project stage:
javax.faces.PROJECT_STAGEDevelopment
Chapter 3 • Getting Started with Web Applications
87
Web Modules: The hello1 Example
A context parameter provides configuration information needed by a web application. An
application can define its own context parameters. In addition, JavaServer Faces technology
and Java Servlet technology define context parameters that an application can use.
■ A servlet element and its servlet-mapping element specifying the FacesServlet:
Faces Servletjavax.faces.webapp.FacesServlet1Faces Servlet/faces/*
■ A welcome-file-list element specifying the location of the landing page; note that the
location is faces/index.xhtml, not just index.xhtml:
faces/index.xhtml
Introduction to Scopes
In the Hello.java class, the annotations javax.faces.bean.ManagedBean and
javax.faces.bean.RequestScoped identify the class as a JavaServer Faces managed bean using
request scope. Scope defines how application data persists and is shared.
The most commonly used scopes in JavaServer Faces applications are the following:
■ Request (@RequestScoped): Request scope persists during a single HTTP request in a web
■
application. In an application like hello1, where the application consists of a single request
and response, the bean uses request scope.
Session (@SessionScoped): Session scope persists across multiple HTTP requests in a web
application. When an application consists of multiple requests and responses where data
needs to be maintained, beans use session scope.
■ Application (@ApplicationScoped): Application scope persists across all users’ interactions
with a web application.
For more information on scopes in JavaServer Faces technology, see “Using Managed Bean
Scopes” on page 296.
Packaging a Web Module
A web module must be packaged into a WAR in certain deployment scenarios and whenever
you want to distribute the web module. You package a web module into a WAR by executing
the jar command in a directory laid out in the format of a web module, by using the Ant utility,
or by using the IDE tool of your choice. This tutorial shows you how to use NetBeans IDE or
Ant to build, package, and deploy the hello1 sample application.
88
The Java EE 6 Tutorial • January 2013
Web Modules: The hello1 Example
▼ To Set the Context Root
A context root identifies a web application in a Java EE server. A context root must start with a
forward slash (/) and end with a string.
In a packaged web module for deployment on the GlassFish Server, the context root is stored in
glassfish-web.xml.
1
2
3
4
To view or edit the context root, follow these steps.
Expand the Web Pages and WEB-INF nodes of the hello1 project.
Double-click glassfish-web.xml.
In the General tab, observe that the Context Root field is set to /hello1.
If you needed to edit this value, you could do so here. When you create a new application, you
type the context root here.
(Optional) Click the XML tab.
Observe that the context root value /hello1 is enclosed by the context-root element. You
could also edit the value here.
▼ To Build and Package the hello1 Web Module Using NetBeans IDE
1
2
3
4
5
6
From the File menu, choose Open Project.
In the Open Project dialog, navigate to:
tut-install/examples/web/
Select the hello1 folder.
Select the Open as Main Project check box.
Click Open Project.
In the Projects tab, right-click the hello1 project and select Build.
▼ To Build and Package the hello1 Web Module Using Ant
1
2
In a terminal window, go to:
tut-install/examples/web/hello1/
Type the following command:
ant
Chapter 3 • Getting Started with Web Applications
89
Web Modules: The hello1 Example
This command spawns any necessary compilations, copies files to the directory
tut-install/examples/web/hello1/build/, creates the WAR file, and copies it to the directory
tut-install/examples/web/hello1/dist/.
Deploying a Web Module
You can deploy a WAR file to the GlassFish Server by
■ Using NetBeans IDE
■ Using the Ant utility
■ Using the asadmin command
■ Using the Administration Console
■ Copying the WAR file into the domain-dir/autodeploy/ directory
Throughout the tutorial, you will use NetBeans IDE or Ant for packaging and deploying.
▼ To Deploy the hello1 Web Module Using NetBeans IDE
●
Right-click the hello1 project and select Deploy.
▼ To Deploy the hello1 Web Module Using Ant
1
2
In a terminal window, go to:
tut-install/examples/web/hello1/
Type the following command:
ant deploy
Running a Deployed Web Module
Now that the web module is deployed, you can view it by opening the application in a web
browser. By default, the application is deployed to host localhost on port 8080. The context
root of the web application is hello1.
▼ To Run a Deployed Web Module
1
2
3
Open a web browser.
Type the following URL:
http://localhost:8080/hello1/
Type your name and click Submit.
The response page displays the name you submitted. Click the Back button to try again.
90
The Java EE 6 Tutorial • January 2013
Web Modules: The hello1 Example
Listing Deployed Web Modules
The GlassFish Server provides two ways to view the deployed web modules: the Administration
Console and the asadmin command.
▼ To List Deployed Web Modules Using the Administration Console
1
2
Open the URL http://localhost:4848/ in a browser.
Select the Applications node.
The deployed web modules appear in the Deployed Applications table.
▼ To List Deployed Web Modules Using the asadmin Command
●
Type the following command:
asadmin list-applications
Updating a Web Module
A typical iterative development cycle involves deploying a web module and then making
changes to the application components. To update a deployed web module, follow these steps.
▼ To Update a Deployed Web Module
1
2
3
Recompile any modified classes.
Redeploy the module.
Reload the URL in the client.
Dynamic Reloading
If dynamic reloading is enabled, you do not have to redeploy an application or module when
you change its code or deployment descriptors. All you have to do is copy the changed pages or
class files into the deployment directory for the application or module. The deployment
directory for a web module named context-root is domain-dir/applications/context-root. The
server checks for changes periodically and redeploys the application, automatically and
dynamically, with the changes.
Chapter 3 • Getting Started with Web Applications
91
Web Modules: The hello1 Example
This capability is useful in a development environment because it allows code changes to be
tested quickly. Dynamic reloading is not recommended for a production environment,
however, because it may degrade performance. In addition, whenever a reload is done, the
sessions at that time become invalid, and the client must restart the session.
In the GlassFish Server, dynamic reloading is enabled by default.
▼ To Disable or Modify Dynamic Reloading
If for some reason you do not want the default dynamic reloading behavior, follow these steps in
the Administration Console.
1
2
3
4
5
Open the URL http://localhost:4848/ in a browser.
Select the GlassFish Server node.
Select the Advanced tab.
To disable dynamic reloading, deselect the Reload Enabled check box.
To change the interval at which applications and modules are checked for code changes and
dynamically reloaded, type a number of seconds in the Reload Poll Interval field.
The default value is 2 seconds.
6
Click the Save button.
Undeploying Web Modules
You can undeploy web modules and other types of enterprise applications by using either
NetBeans IDE or the Ant tool.
▼ To Undeploy the hello1 Web Module Using NetBeans IDE
1
2
3
4
Ensure that the GlassFish Server is running.
In the Services window, expand the Servers node, GlassFish Server instance, and the
Applications node.
Right-click the hello1 module and choose Undeploy.
To delete the class files and other build artifacts, right-click the project and choose Clean.
92
The Java EE 6 Tutorial • January 2013
▼ To Undeploy the hello1 Web Module Using Ant
Configuring Web Applications: The hello2 Example
1
2
3
In a terminal window, go to:
tut-install/examples/web/hello1/
Type the following command:
ant undeploy
To delete the class files and other build artifacts, type the following command:
ant clean
Configuring Web Applications: The hello2 Example
Web applications are configured by means of annotations or by elements contained in the web
application deployment descriptor.
The following sections give a brief introduction to the web application features you will usually
want to configure. Examples demonstrate procedures for configuring the Hello, World
application.
Mapping URLs to Web Components
When it receives a request, the web container must determine which web component should
handle the request. The web container does so by mapping the URL path contained in the
request to a web application and a web component. A URL path contains the context root and,
optionally, a URL pattern:
http://host:port/context-root[/url-pattern]
You set the URL pattern for a servlet by using the @WebServlet annotation in the servlet source
file. For example, the GreetingServlet.java file in the hello2 application contains the
following annotation, specifying the URL pattern as /greeting:
@WebServlet("/greeting")
public class GreetingServlet extends HttpServlet {
...
This annotation indicates that the URL pattern /greeting follows the context root. Therefore,
when the servlet is deployed locally, it is accessed with the following URL:
http://localhost:8080/hello2/greeting
To access the servlet by using only the context root, specify "/" as the URL pattern.
Chapter 3 • Getting Started with Web Applications
93
Configuring Web Applications: The hello2 Example
Examining the hello2 Web Module
The hello2 application behaves almost identically to the hello1 application, but it is
implemented using Java Servlet technology instead of JavaServer Faces technology. You can use
a text editor to view the application files, or you can use NetBeans IDE.
▼ To View the hello2 Web Module Using NetBeans IDE
1
2
3
4
5
6
From the File menu, choose Open Project.
In the Open Project dialog, navigate to:
tut-install/examples/web/
Select the hello2 folder.
Select the Open as Main Project check box.
Expand the Source Packages node, then the servlets node.
Double-click the GreetingServlet.java file to view it.
This servlet overrides the doGet method, implementing the GET method of HTTP. The servlet
displays a simple HTML greeting form whose Submit button, like that of hello1, specifies a
response page for its action. The following excerpt begins with the @WebServlet annotation
that specifies the URL pattern, relative to the context root:
@WebServlet("/greeting")
public class GreetingServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
response.setBufferSize(8192);
PrintWriter out = response.getWriter();
// then write the data of the response
out.println(""
+ "Servlet Hello");
// then write the data of the response
out.println(""
+ ""
+ "");
String username = request.getParameter("username");
if (username != null && username.length() > 0) {
RequestDispatcher dispatcher =
getServletContext().getRequestDispatcher("/response");
if (dispatcher != null) {
dispatcher.include(request, response);
}
}
out.println("");
out.close();
}
...
7
Double-click the ResponseServlet.java file to view it.
This servlet also overrides the doGet method, displaying only the response. The following
excerpt begins with the @WebServlet annotation, which specifies the URL pattern, relative to
the context root:
@WebServlet("/response")
public class ResponseServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
// then write the data of the response
String username = request.getParameter("username");
if (username != null && username.length() > 0) {
out.println("
Hello, " + username + "!
");
}
}
...
8
Under the Web Pages node, expand the WEB-INF node and double-click the
glassfish-web.xml file to view it.
In the General tab, observe that the Context Root field is set to /hello2.
For this simple servlet application, a web.xml file is not required.
Running the hello2 Example
You can use either NetBeans IDE or Ant to build, package, deploy, and run the hello2 example.
Chapter 3 • Getting Started with Web Applications
95
Configuring Web Applications: The hello2 Example
▼ To Run the hello2 Example Using NetBeans IDE
1
2
3
4
5
6
7
8
From the File menu, choose Open Project.
In the Open Project dialog, navigate to:
tut-install/examples/web/
Select the hello2 folder.
Select the Open as Main Project check box.
Click Open Project.
In the Projects tab, right-click the hello2 project and select Build.
Right-click the project and select Deploy.
In a web browser, open the URL http://localhost:8080/hello2/greeting.
The URL specifies the context root, followed by the URL pattern.
The application looks much like the hello1 application. The major difference is that after you
click the Submit button, the response appears below the greeting, not on a separate page.
▼ To Run the hello2 Example Using Ant
1
In a terminal window, go to:
tut-install/examples/web/hello2/
2
Type the following command:
ant
This target builds the WAR file and copies it to the tut-install/examples/web/hello2/dist/
directory.
3
Type ant deploy.
Ignore the URL shown in the deploy target output.
4
In a web browser, open the URL http://localhost:8080/hello2/greeting.
The URL specifies the context root, followed by the URL pattern.
The application looks much like the hello1 application. The major difference is that after you
click the Submit button, the response appears below the greeting, not on a separate page.
96
The Java EE 6 Tutorial • January 2013
Configuring Web Applications: The hello2 Example
Declaring Welcome Files
The welcome files mechanism allows you to specify a list of files that the web container will use
for appending to a request for a URL (called a valid partial request) that is not mapped to a web
component. For example, suppose that you define a welcome file welcome.html. When a client
requests a URL such as host:port/webapp/directory, where directory is not mapped to a servlet
or XHTML page, the file host:port/webapp/directory/welcome.html is returned to the client.
If a web container receives a valid partial request, the web container examines the welcome file
list and appends to the partial request each welcome file in the order specified and checks
whether a static resource or servlet in the WAR is mapped to that request URL. The web
container then sends the request to the first resource that matches in the WAR.
If no welcome file is specified, the GlassFish Server will use a file named index.html as the
default welcome file. If there is no welcome file and no file named index.html, the GlassFish
Server returns a directory listing.
By convention, you specify the welcome file for a JavaServer Faces application as
faces/file-name.xhtml.
Setting Context Parameters
The web components in a web module share an object that represents their application context.
You can pass context parameters to the context, or initialization parameters to a servlet.
Context parameters are available to the entire web application. For information on
initialization parameters, see “Creating and Initializing a Servlet” on page 331.
▼ To Add a Context Parameter Using NetBeans IDE
These steps apply generally to web applications, but do not apply specifically to the examples in
this chapter.
1
2
3
4
5
6
Open the project.
Expand the project’s node in the Projects pane.
Expand the Web Pages node and then the WEB-INF node.
Double-click web.xml.
If the project does not have a web.xml file, follow the steps in “To Create a web.xml File Using
NetBeans IDE” on page 98.
Click General at the top of the editor pane.
Expand the Context Parameters node.
Chapter 3 • Getting Started with Web Applications
97
Configuring Web Applications: The hello2 Example
7
Click Add.
An Add Context Parameter dialog opens.
8
9
In the Parameter Name field, type the name that specifies the context object.
In the Parameter Value field, type the parameter to pass to the context object.
10
Click OK.
▼ To Create a web.xml File Using NetBeans IDE
1
2
3
4
From the File menu, choose New File.
In the New File wizard, select the Web category, then select Standard Deployment Descriptor
under File Types.
Click Next.
Click Finish.
A basic web.xml file appears in web/WEB-INF/.
Mapping Errors to Error Screens
When an error occurs during execution of a web application, you can have the application
display a specific error screen according to the type of error. In particular, you can specify a
mapping between the status code returned in an HTTP response or a Java programming
language exception returned by any web component and any type of error screen.
You can have multiple error-page elements in your deployment descriptor. Each element
identifies a different error that causes an error page to open. This error page can be the same for
any number of error-page elements.
▼ To Set Up Error Mapping Using NetBeans IDE
These steps apply generally to web applications, but do not apply specifically to the examples in
this chapter.
1
2
3
Open the project.
Expand the project’s node in the Projects pane.
Expand the Web Pages node and then the WEB-INF node.
98
The Java EE 6 Tutorial • January 2013
4
5
6
7
8
9
Configuring Web Applications: The hello2 Example
Double-click web.xml.
If the project does not have a web.xml file, follow the steps in “To Create a web.xml File Using
NetBeans IDE” on page 98.
Click Pages at the top of the editor pane.
Expand the Error Pages node.
Click Add.
The Add Error Page dialog opens.
Click Browse to locate the page that you want to act as the error page.
Specify either an error code or an exception type:
■ To specify an error code, in the Error Code field, type the HTTP status code that will cause
the error page to be opened, or leave the field blank to include all error codes.
■ To specify an exception type, in the Exception Type field, type the exception that will cause
the error page to load. To specify all throwable errors and exceptions, type
java.lang.Throwable.
10
Click OK.
Declaring Resource References
If your web component uses such objects as enterprise beans, data sources, or web services, you
use Java EE annotations to inject these resources into your application. Annotations eliminate a
lot of the boilerplate lookup code and configuration elements that previous versions of Java EE
required.
Although resource injection using annotations can be more convenient for the developer, there
are some restrictions on using it in web applications. First, you can inject resources only into
container-managed objects, since a container must have control over the creation of a
component so that it can perform the injection into a component. As a result, you cannot inject
resources into such objects as simple JavaBeans components. However, JavaServer Faces
managed beans and CDI managed beans are managed by the container; therefore, they can
accept resource injections.
Components that can accept resource injections are listed in Table 3–1.
This section explains how to use a couple of the annotations supported by a web container to
inject resources. Chapter 33, “Running the Persistence Examples,” explains how web
applications use annotations supported by the Java Persistence API. Chapter 40, “Getting
Chapter 3 • Getting Started with Web Applications
99
Configuring Web Applications: The hello2 Example
Started Securing Web Applications,” explains how to use annotations to specify information
about securing web applications. See Chapter 45, “Resources and Resource Adapters,” for more
information on resources.
TABLE 3–1 Web Components That Accept Resource Injections
Component
Interface/Class
Servlets
javax.servlet.Servlet
Servlet filters
javax.servlet.ServletFilter
Event listeners
javax.servlet.ServletContextListener
javax.servlet.ServletContextAttributeListener
javax.servlet.ServletRequestListener
javax.servlet.ServletRequestAttributeListener
javax.servlet.http.HttpSessionListener
javax.servlet.http.HttpSessionAttributeListener
javax.servlet.http.HttpSessionBindingListener
Managed beans
Plain Old Java Objects
Declaring a Reference to a Resource
The @Resource annotation is used to declare a reference to a resource, such as a data source, an
enterprise bean, or an environment entry.
The @Resource annotation is specified on a class, a method, or a field. The container is
responsible for injecting references to resources declared by the @Resource annotation and
mapping it to the proper JNDI resources.
In the following example, the @Resource annotation is used to inject a data source into a
component that needs to make a connection to the data source, as is done when using JDBC
technology to access a relational database:
@Resource javax.sql.DataSource catalogDS;
public getProductsByCategory() {
// get a connection and execute the query
Connection conn = catalogDS.getConnection();
...
}
The container injects this data source prior to the component’s being made available to the
application. The data source JNDI mapping is inferred from the field name catalogDS and the
type, javax.sql.DataSource.
If you have multiple resources that you need to inject into one component, you need to use the
@Resources annotation to contain them, as shown by the following example:
100
The Java EE 6 Tutorial • January 2013
Further Information about Web Applications
@Resources ({
})
@Resource (name="myDB" type=java.sql.DataSource),
@Resource(name="myMQ" type=javax.jms.ConnectionFactory)
The web application examples in this tutorial use the Java Persistence API to access relational
databases. This API does not require you to explicitly create a connection to a data source.
Therefore, the examples do not use the @Resource annotation to inject a data source. However,
this API supports the @PersistenceUnit and @PersistenceContext annotations for injecting
EntityManagerFactory and EntityManager instances, respectively. Chapter 33, “Running the
Persistence Examples,” describes these annotations and the use of the Java Persistence API in
web applications.
Declaring a Reference to a Web Service
The @WebServiceRef annotation provides a reference to a web service. The following example
shows uses the @WebServiceRef annotation to declare a reference to a web service.
WebServiceRef uses the wsdlLocation element to specify the URI of the deployed service’s
WSDL file:
...
import javax.xml.ws.WebServiceRef;
...
public class ResponseServlet extends HTTPServlet {
@WebServiceRef(wsdlLocation=
"http://localhost:8080/helloservice/hello?wsdl")
static HelloService service;
Further Information about Web Applications
For more information on web applications, see
■
■
■
■
JavaServer Faces 2.0 specification:
http://jcp.org/en/jsr/detail?id=314
JavaServer Faces technology web site:
http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html
Java Servlet 3.0 specification:
http://jcp.org/en/jsr/detail?id=315
Java Servlet web site:
http://www.oracle.com/technetwork/java/index-jsp-135475.html
Chapter 3 • Getting Started with Web Applications
101
102
4C H A P T E R 4
JavaServer Faces Technology
JavaServer Faces technology is a server-side component framework for building Java
technology-based web applications.
JavaServer Faces technology consists of the following:
■ An API for representing components and managing their state; handling events, server-side
validation, and data conversion; defining page navigation; supporting internationalization
and accessibility; and providing extensibility for all these features
■ Tag libraries for adding components to web pages and for connecting components to
server-side objects
JavaServer Faces technology provides a well-defined programming model and various tag
libraries. The tag libraries contain tag handlers that implement the component tags. These
features significantly ease the burden of building and maintaining web applications with
server-side user interfaces (UIs). With minimal effort, you can complete the following tasks.
■ Create a web page.
■ Drop components onto a web page by adding component tags.
■ Bind components on a page to server-side data.
■ Wire component-generated events to server-side application code.
Save and restore application state beyond the life of server requests.
■
■ Reuse and extend components through customization.
This chapter provides an overview of JavaServer Faces technology. After explaining what a
JavaServer Faces application is and reviewing some of the primary benefits of using JavaServer
Faces technology, this chapter describes the process of creating a simple JavaServer Faces
application. This chapter also introduces the JavaServer Faces lifecycle by describing the
example JavaServer Faces application progressing through the lifecycle stages.
The following topics are addressed here:
■ “What Is a JavaServer Faces Application?” on page 104
■ “JavaServer Faces Technology Benefits” on page 105
103
What Is a JavaServer Faces Application?
■ “Creating a Simple JavaServer Faces Application” on page 106
■ “Further Information about JavaServer Faces Technology” on page 110
What Is a JavaServer Faces Application?
The functionality provided by a JavaServer Faces application is similar to that of any other Java
web application. A typical JavaServer Faces application includes the following parts:
■ A set of web pages in which components are laid out
■ A set of tags to add components to the web page
■ A set of managed beans, which are lightweight container-managed objects (POJOs) with
minimal requirements. They support a small set of basic services, such as resource injection,
lifecycle callbacks and interceptors.
■ A web deployment descriptor (web.xml file)
■ Optionally, one or more application configuration resource files, such as a
faces-config.xml file, which can be used to define page navigation rules and configure
beans and other custom objects, such as custom components
■ Optionally, a set of custom objects, which can include custom components, validators,
converters, or listeners, created by the application developer
■ Optionally, a set of custom tags for representing custom objects on the page
Figure 4–1 shows the interaction between client and server in a typical JavaServer Faces
application. In response to a client request, a web page is rendered by the web container that
implements JavaServer Faces technology.
FIGURE 4–1 Responding to a Client Request for a JavaServer Faces Page
Access page
HTTP Request
Browser
Web Container
myfacelet.xhtml
Renders HTML
HTTP Response
myUI
104
The Java EE 6 Tutorial • January 2013
JavaServer Faces Technology Benefits
The web page, myfacelet.xhtml, is built using JavaServer Faces component tags. Component
tags are used to add components to the view (represented by myUI in the diagram), which is the
server-side representation of the page. In addition to components, the web page can also
reference objects, such as the following:
■ Any event listeners, validators, and converters that are registered on the components
■ The JavaBeans components that capture the data and process the application-specific
functionality of the components
On request from the client, the view is rendered as a response. Rendering is the process
whereby, based on the server-side view, the web container generates output, such as HTML or
XHTML, that can be read by the client, such as a browser.
JavaServer Faces Technology Benefits
One of the greatest advantages of JavaServer Faces technology is that it offers a clean separation
between behavior and presentation for web applications. A JavaServer Faces application can
map HTTP requests to component-specific event handling and manage components as stateful
objects on the server. JavaServer Faces technology allows you to build web applications that
implement the finer-grained separation of behavior and presentation that is traditionally
offered by client-side UI architectures.
The separation of logic from presentation also allows each member of a web application
development team to focus on a single piece of the development process and provides a simple
programming model to link the pieces. For example, page authors with no programming
expertise can use JavaServer Faces technology tags in a web page to link to server-side objects
without writing any scripts.
Another important goal of JavaServer Faces technology is to leverage familiar component and
web-tier concepts without limiting you to a particular scripting technology or markup
language. JavaServer Faces technology APIs are layered directly on top of the Servlet API, as
shown in Figure 4–2.
FIGURE 4–2
Java Web Application Technologies
JavaServer Faces
Java Servlet
JavaServer Pages
Standard Tag Library
JavaServer Pages
Chapter 4 • JavaServer Faces Technology
105
Creating a Simple JavaServer Faces Application
This layering of APIs enables several important application use cases, such as using different
presentation technologies, creating your own custom components directly from the component
classes, and generating output for various client devices.
Facelets technology, available as part of JavaServer Faces 2.0, is now the preferred presentation
technology for building JavaServer Faces technology-based web applications. For more
information on Facelets technology features, see Chapter 5, “Introduction to Facelets.”
Facelets technology offers several advantages.
■ Code can be reused and extended for components through the templating and composite
component features.
■ When you use the JavaServer Faces Annotations feature, you can automatically register the
managed bean as a resource available for JavaServer Faces applications. In addition, implicit
navigation rules allow developers to quickly configure page navigation. These features
reduce the manual configuration process for applications.
■ Most important, JavaServer Faces technology provides a rich architecture for managing
component state, processing component data, validating user input, and handling events.
Creating a Simple JavaServer Faces Application
JavaServer Faces technology provides an easy and user-friendly process for creating web
applications. Developing a simple JavaServer Faces application typically requires the following
tasks:
■ Developing managed beans
■ Creating web pages using component tags
■ Mapping the javax.faces.webapp.FacesServlet instance
This section describes those tasks through the process of creating a simple JavaServer Faces
Facelets application.
The example is a Hello application that includes a managed bean and a web page. When
accessed by a client, the web page prints out a Hello World message. The example application is
located in the tut-install/examples/web/hello/ directory. The tasks involved in developing
this application can be examined by looking at the application components in detail.
Developing the Managed Bean
As mentioned earlier in this chapter, a managed bean is a lightweight container-managed
object. Components in a page are associated with managed beans that provide application logic.
The example managed bean, Hello.java, contains the following code:
106
The Java EE 6 Tutorial • January 2013
Creating a Simple JavaServer Faces Application
package hello;
import javax.faces.bean.ManagedBean;
@ManagedBean
public class Hello {
final String world = "Hello World!";
public String getworld() {
return world;
}
}
The example managed bean sets the value of the variable world with the string "Hello World!".
The @ManagedBean annotation registers the managed bean as a resource with the JavaServer
Faces implementation. For more information on managed beans and annotations, see
Chapter 9, “Developing with JavaServer Faces Technology.”
Creating the Web Page
In a typical Facelets application, web pages are created in XHTML. The example web page,
beanhello.xhtml, is a simple XHTML page. It has the following content:
xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html">
Facelets Hello World
#{hello.world}
A Facelets XHTML web page can also contain several other elements, which are covered later in
this tutorial.
The web page connects to the managed bean through the Expression Language (EL) value
expression #{hello.world}, which retrieves the value of the world property from the managed
bean Hello. Note the use of hello to reference the managed bean Hello. If no name is specified
in the @ManagedBean annotation, the managed bean is always accessed with the first letter of the
class name in lowercase.
For more information on using EL expressions, see Chapter 6, “Expression Language.” For
more information about Facelets technology, see Chapter 5, “Introduction to Facelets.” For
more information about the JavaServer Faces programming model and building web pages
using JavaServer Faces technology, see Chapter 7, “Using JavaServer Faces Technology in Web
Pages.”
Chapter 4 • JavaServer Faces Technology
107
Creating a Simple JavaServer Faces Application
Mapping the FacesServlet Instance
The final task requires mapping the FacesServlet, which is done through the web deployment
descriptor (web.xml). A typical mapping of FacesServlet is as follows:
Faces Servletjavax.faces.webapp.FacesServlet1Faces Servlet/faces/*
The preceding file segment represents part of a typical JavaServer Faces web deployment
descriptor. The web deployment descriptor can also contain other content relevant to a
JavaServer Faces application configuration, but that information is not covered here.
Mapping the FacesServlet is automatically done for you if you are using an IDE such as
NetBeans IDE.
The Lifecycle of the hello Application
Every web application has a lifecycle. Common tasks, such as handling incoming requests,
decoding parameters, modifying and saving state, and rendering web pages to the browser, are
all performed during a web application lifecycle. Some web application frameworks hide the
details of the lifecycle from you, whereas others require you to manage them manually.
By default, JavaServer Faces automatically handles most of the lifecycle actions for you.
However, it also exposes the various stages of the request lifecycle, so that you can modify or
perform different actions if your application requirements warrant it.
It is not necessary for the beginning user to understand the lifecycle of a JavaServer Faces
application, but the information can be useful for creating more complex applications.
The lifecycle of a JavaServer Faces application starts and ends with the following activity: The
client makes a request for the web page, and the server responds with the page. The lifecycle
consists of two main phases: execute and render.
During the execute phase, several actions can take place:
■ The application view is built or restored.
■ The request parameter values are applied.
■ Conversions and validations are performed for component values.
■ Managed beans are updated with component values.
■ Application logic is invoked.
108
The Java EE 6 Tutorial • January 2013
Creating a Simple JavaServer Faces Application
For a first (initial) request, only the view is built. For subsequent (postback) requests, some or all
of the other actions can take place.
In the render phase, the requested view is rendered as a response to the client. Rendering is
typically the process of generating output, such as HTML or XHTML, that can be read by the
client, usually a browser.
The following short description of the example JavaServer Faces application passing through its
lifecycle summarizes the activity that takes place behind the scenes.
The hello example application goes through the following stages when it is deployed on the
GlassFish Server.
1. When the hello application is built and deployed on the GlassFish Server, the application is
in an uninitiated state.
2. When a client makes an initial request for the beanhello.xhtml web page, the hello
Facelets application is compiled.
3. The compiled Facelets application is executed, and a new component tree is constructed for
the hello application and is placed in a javax.faces.context.FacesContext.
4. The component tree is populated with the component and the managed bean property
associated with it, represented by the EL expression hello.world.
5. A new view is built, based on the component tree.
6. The view is rendered to the requesting client as a response.
7. The component tree is destroyed automatically.
8. On subsequent (postback) requests, the component tree is rebuilt, and the saved state is
applied.
For more detailed information on the JavaServer Faces lifecycle, see Chapter 10, “JavaServer
Faces Technology: Advanced Concepts.”
Running the hello Application
You can use either NetBeans IDE or Ant to build, package, deploy, and run the hello example.
▼ To Run the hello Application in NetBeans IDE
1
2
3
From the File menu, choose Open Project.
In the Open Project dialog box, navigate to:
tut-install/examples/web
Select the hello folder.
Chapter 4 • JavaServer Faces Technology
109
Further Information about JavaServer Faces Technology
4
5
6
Select the Open as Main Project check box.
Click Open Project.
In the Projects tab, right-click the hello project and select Run.
This step compiles, assembles, and deploys the application and then brings up a web browser
window displaying the following URL:
http://localhost:8080/hello
The output looks like this:
Hello World!
▼ To Run the hello Example Using Ant
1
2
3
4
In a terminal window, go to:
tut-install/examples/web/hello/
Type the following command:
ant
This target builds the WAR file and copies it to the tut-install/examples/web/hello/dist/
directory.
Type ant deploy.
In a web browser, type the following URL:
http://localhost:8080/hello/
The output looks like this:
Hello World!
Further Information about JavaServer Faces Technology
For more information on JavaServer Faces technology, see
■
■
JavaServer Faces 2.0 specification:
http://jcp.org/en/jsr/detail?id=314
JavaServer Faces project web site:
http://javaserverfaces.java.net/
■ Mojarra (JavaServer Faces 2.0 implementation) Release Notes:
http://javaserverfaces.java.net/nonav/rlnotes/2.1.4/
110
The Java EE 6 Tutorial • January 2013
5C H A P T E R 5
Introduction to Facelets
The term Facelets refers to the view declaration language for JavaServer Faces technology.
JavaServer Pages (JSP) technology, previously used as the presentation technology for
JavaServer Faces, does not support all the new features available in JavaServer Faces in the Java
EE 6 platform. JSP technology is considered to be a deprecated presentation technology for
JavaServer Faces. Facelets is a part of the JavaServer Faces specification and also the preferred
presentation technology for building JavaServer Faces technology-based applications.
The following topics are addressed here:
■ “What Is Facelets?” on page 111
■ “Developing a Simple Facelets Application” on page 113
■ “Using Facelets Templates” on page 119
■ “Composite Components” on page 121
■ “Web Resources” on page 123
What Is Facelets?
Facelets is a powerful but lightweight page declaration language that is used to build JavaServer
Faces views using HTML style templates and to build component trees. Facelets features
include the following:
■ Use of XHTML for creating web pages
■
■
Support for Facelets tag libraries in addition to JavaServer Faces and JSTL tag libraries
Support for the Expression Language (EL)
■ Templating for components and pages
Advantages of Facelets for large-scale development projects include the following:
■
Support for code reuse through templating and composite components
■ Functional extensibility of components and other server-side objects through customization
111
What Is Facelets?
■ Faster compilation time
■ Compile-time EL validation
■ High-performance rendering
In short, the use of Facelets reduces the time and effort that needs to be spent on development
and deployment.
Facelets views are usually created as XHTML pages. JavaServer Faces implementations support
XHTML pages created in conformance with the XHTML Transitional Document Type
Definition (DTD), as listed at http://www.w3.org/TR/xhtml1/
#a_dtd_XHTML-1.0-Transitional. By convention, web pages built with XHTML have an
.xhtml extension.
JavaServer Faces technology supports various tag libraries to add components to a web page. To
support the JavaServer Faces tag library mechanism, Facelets uses XML namespace
declarations. Table 5–1 lists the tag libraries supported by Facelets.
TABLE 5–1 Tag Libraries Supported by Facelets
Tag Library
URI
Prefix
Example
Contents
JavaServer
Faces Facelets
Tag Library
JavaServer
Faces HTML
Tag Library
JavaServer
Faces Core
Tag Library
http://java.sun.com/jsf/facelets
ui:
ui:component
ui:insert
http://java.sun.com/jsf/html
h:
h:head
h:body
h:outputText
h:inputText
http://java.sun.com/jsf/core
f:
f:actionListener
f:attribute
JSTL Core Tag
Library
JSTL
Functions Tag
Library
http://java.sun.com/jsp/jstl/core
c:
c:forEach
http://java.sun.com/jsp/jstl/
functions
c:catch
fn:
fn:toUpperCase
fn:toLowerCase
112
The Java EE 6 Tutorial • January 2013
Tags for
templating
JavaServer
Faces
component
tags for all
UIComponent
objects
Tags for
JavaServer
Faces
custom
actions that
are
independent
of any
particular
render kit
JSTL 1.2
Core Tags
JSTL 1.2
Functions
Tags
Developing a Simple Facelets Application
In addition, Facelets supports tags for composite components, for which you can declare
custom prefixes. For more information on composite components, see “Composite
Components” on page 121.
Based on the JavaServer Faces support for Expression Language (EL) syntax, Facelets uses EL
expressions to reference properties and methods of managed beans. EL expressions can be used
to bind component objects or values to methods or properties of managed beans. For more
information on using EL expressions, see “Using the EL to Reference Managed Beans” on
page 191.
Developing a Simple Facelets Application
This section describes the general steps involved in developing a JavaServer Faces application.
The following tasks are usually required:
■ Developing the managed beans
■ Creating the pages using the component tags
■ Defining page navigation
■ Mapping the javax.faces.webapp.FacesServlet instance
■ Adding managed bean declarations
Creating a Facelets Application
The example used in this tutorial is the guessnumber application. The application presents you
with a page that asks you to guess a number between 0 and 10, validates your input against a
random number, and responds with another page that informs you whether you guessed the
number correctly or incorrectly.
Developing a Managed Bean
In a typical JavaServer Faces application, each page of the application connects to a managed
bean. The managed bean defines the methods and properties that are associated with the
components. In this example, both pages use the same managed bean.
The following managed bean class, UserNumberBean.java, generates a random number from 0
to 10:
package guessNumber;
import java.io.Serializable;
import java.util.Random;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
@ManagedBean
Chapter 5 • Introduction to Facelets
113
Developing a Simple Facelets Application
@SessionScoped
public class UserNumberBean implements Serializable {
private static final long serialVersionUID = 5443351151396868724L;
Integer randomInt = null;
Integer userNumber = null;
String response = null;
private long maximum=10;
private long minimum=0;
public UserNumberBean() {
Random randomGR = new Random();
randomInt = new Integer(randomGR.nextInt(10));
System.out.println("Duke’s number: " + randomInt);
public void setUserNumber(Integer user_number) {
userNumber = user_number;
public Integer getUserNumber() {
return userNumber;
public String getResponse() {
return "Yay! You got it!";
} else {
if ((userNumber != null) && (userNumber.compareTo(randomInt) == 0)) {
return "Sorry, " + userNumber + " is incorrect.";
}
}
}
}
}
public long getMaximum() {
return (this.maximum);
}
public void setMaximum(long maximum) {
this.maximum = maximum;
}
public long getMinimum() {
return (this.minimum);
}
public void setMinimum(long minimum) {
this.minimum = minimum;
}
}
Note the use of the @ManagedBean annotation, which registers the managed bean as a resource
with the JavaServer Faces implementation. The @SessionScoped annotation registers the bean
scope as session.
Creating Facelets Views
To create a page or view, you add components to the pages, wire the components to managed
bean values and properties, and register converters, validators, or listeners on the components.
114
The Java EE 6 Tutorial • January 2013
Developing a Simple Facelets Application
For the example application, XHTML web pages serve as the front end. The first page of the
example application is a page called greeting.xhtml. A closer look at various sections of this
web page provides more information.
The first section of the web page declares the content type for the page, which is XHTML:
The next section specifies the language of the XHTML page, then declares the XML namespace
for the tag libraries that are used in the web page:
The next section uses various tags to insert components into the web page:
Guess Number Facelets Application
Hi, my name is Duke. I am thinking of a number from
#{userNumberBean.minimum} to #{userNumberBean.maximum}.
Can you guess it?
Chapter 5 • Introduction to Facelets
115
Developing a Simple Facelets Application
Note the use of the following tags:
■ Facelets HTML tags (those beginning with h:) to add components
■ The Facelets core tag f:validateLongRange to validate the user input
An h:inputText tag accepts user input and sets the value of the managed bean property
userNumber through the EL expression #{userNumberBean.userNumber}. The input value is
validated for value range by the JavaServer Faces standard validator tag f:validateLongRange.
The image file, wave.med.gif, is added to the page as a resource; so is the style sheet. For more
details about the resources facility, see “Web Resources” on page 123.
An h:commandButton tag with the ID submit starts validation of the input data when a user
clicks the button. Using implicit navigation, the tag redirects the client to another page,
response.xhtml, which shows the response to your input. The page specifies only response,
which by default causes the server to look for response.xhtml.
You can now create the second page, response.xhtml, with the following content:
Guess Number Facelets Application
Configuring the Application
Configuring a JavaServer Faces application involves mapping the Faces Servlet in the web
deployment descriptor file, such as a web.xml file, and possibly adding managed bean
declarations, navigation rules, and resource bundle declarations to the application
configuration resource file, faces-config.xml.
116
The Java EE 6 Tutorial • January 2013
Developing a Simple Facelets Application
If you are using NetBeans IDE, a web deployment descriptor file is automatically created for
you. In such an IDE-created web.xml file, change the default greeting page, which is
index.xhtml, to greeting.xhtml. Here is an example web.xml file, showing this change in
bold.
javax.faces.PROJECT_STAGEDevelopmentFaces Servletjavax.faces.webapp.FacesServlet1Faces Servlet/faces/*
30
faces/greeting.xhtml
Note the use of the context parameter PROJECT_STAGE. This parameter identifies the status of a
JavaServer Faces application in the software lifecycle.
The stage of an application can affect the behavior of the application. For example, if the project
stage is defined as Development, debugging information is automatically generated for the user.
If not defined by the user, the default project stage is Production.
Running the guessnumber Facelets Example
You can use either NetBeans IDE or Ant to build, package, deploy, and run the guessnumber
example. The source code for this example is available in the
tut-install/examples/web/guessnumber/ directory.
Chapter 5 • Introduction to Facelets
117
Developing a Simple Facelets Application
▼ To Build, Package, and Deploy the guessnumber Example Using
NetBeans IDE
From the File menu, choose Open Project.
In the Open Project dialog, navigate to:
tut-install/examples/web/
Select the guessnumber folder.
Select the Open as Main Project check box.
Click Open Project.
In the Projects tab, right-click the guessnumber project and select Deploy.
This option builds and deploys the example application to your GlassFish Server instance.
1
2
3
4
5
6
▼ To Build, Package, and Deploy the guessnumber Example Using Ant
1
In a terminal window, go to:
tut-install/examples/web/guessnumber/
2
Type the following command:
ant
This command calls the default target, which builds and packages the application into a WAR
file, guessnumber.war, that is located in the dist directory.
3
4
Make sure that the GlassFish Server is started.
To deploy the application, type the following command:
ant deploy
▼ To Run the guessnumber Example
1
2
Open a web browser.
Type the following URL in your web browser:
http://localhost:8080/guessnumber
A web page opens.
118
The Java EE 6 Tutorial • January 2013
Using Facelets Templates
3
In the text field, type a number from 0 to 10 and click Submit.
Another page appears, reporting whether your guess is correct or incorrect.
4
If you guessed incorrectly, click the Back button to return to the main page.
You can continue to guess until you get the correct answer.
Using Facelets Templates
JavaServer Faces technology provides the tools to implement user interfaces that are easy to
extend and reuse. Templating is a useful Facelets feature that allows you to create a page that
will act as the base, or template, for the other pages in an application. By using templates, you
can reuse code and avoid recreating similarly constructed pages. Templating also helps in
maintaining a standard look and feel in an application with a large number of pages.
Table 5–2 lists Facelets tags that are used for templating and their respective functionality.
TABLE 5–2 Facelets Templating Tags
Tag
Function
ui:component
Defines a component that is created and added to the component tree.
ui:composition
Defines a page composition that optionally uses a template. Content outside of this
tag is ignored.
ui:debug
ui:decorate
ui:define
ui:fragment
ui:include
ui:insert
ui:param
ui:repeat
ui:remove
Defines a debug component that is created and added to the component tree.
Similar to the composition tag but does not disregard content outside this tag.
Defines content that is inserted into a page by a template.
Similar to the component tag but does not disregard content outside this tag.
Encapsulate and reuse content for multiple pages.
Inserts content into a template.
Used to pass parameters to an included file.
Used as an alternative for loop tags, such as c:forEach or h:dataTable.
Removes content from a page.
For more information on Facelets templating tags, see the documentation at
http://docs.oracle.com/javaee/6/javaserverfaces/2.1/docs/vdldocs/facelets/.
The Facelets tag library includes the main templating tag ui:insert. A template page that is
created with this tag allows you to define a default structure for a page. A template page is used
as a template for other pages, usually referred to as client pages.
Chapter 5 • Introduction to Facelets
119
Using Facelets Templates
Here is an example of a template saved as template.xhtml:
Facelets Template
Top Section
Left Section
Main Content
The example page defines an XHTML page that is divided into three sections: a top section, a
left section, and a main section. The sections have style sheets associated with them. The same
structure can be reused for the other pages of the application.
The client page invokes the template by using the ui:composition tag. In the following
example, a client page named templateclient.xhtml invokes the template page named
template.xhtml from the preceding example. A client page allows content to be inserted with
the help of the ui:define tag.
Welcome to Template Client Page
120
The Java EE 6 Tutorial • January 2013
Composite Components
You can use NetBeans IDE to create Facelets template and client pages. For more information
on creating these pages, see http://netbeans.org/kb/docs/web/jsf20-intro.html.
Composite Components
JavaServer Faces technology offers the concept of composite components with Facelets. A
composite component is a special type of template that acts as a component.
Any component is essentially a piece of reusable code that behaves in a particular way. For
example, an input component accepts user input. A component can also have validators,
converters, and listeners attached to it to perform certain defined actions.
A composite component consists of a collection of markup tags and other existing components.
This reusable, user-created component has a customized, defined functionality and can have
validators, converters, and listeners attached to it like any other component.
With Facelets, any XHTML page that contains markup tags and other components can be
converted into a composite component. Using the resources facility, the composite component
can be stored in a library that is available to the application from the defined resources location.
Table 5–3 lists the most commonly used composite tags and their functions.
TABLE 5–3 Composite Component Tags
Tag
Function
composite:interface
composite:implementation
composite:attribute
composite:insertChildren
Declares the usage contract for a composite component. The
composite component can be used as a single component whose
feature set is the union of the features declared in the usage contract.
Defines the implementation of the composite component. If a
composite:interface element appears, there must be a
corresponding composite:implementation.
Declares an attribute that may be given to an instance of the
composite component in which this tag is declared.
Any child components or template text within the composite
component tag in the using page will be reparented into the
composite component at the point indicated by this tag’s placement
within the composite:implementation section.
Chapter 5 • Introduction to Facelets
121
Composite Components
TABLE 5–3 Composite Component Tags
Tag
(Continued)
Function
composite:valueHolder
composite:editableValueHolder
composite:actionSource
Declares that the composite component whose contract is declared
by the composite:interface in which this element is nested exposes
an implementation of javax.faces.component.ValueHolder
suitable for use as the target of attached objects in the using page.
Declares that the composite component whose contract is declared
by the composite:interface in which this element is nested exposes
an implementation of
javax.faces.component.EditableValueHolder suitable for use as
the target of attached objects in the using page.
Declares that the composite component whose contract is declared
by the composite:interface in which this element is nested exposes
an implementation of javax.faces.component.ActionSource2
suitable for use as the target of attached objects in the using page.
For more information and a complete list of Facelets composite tags, see the documentation at
http://docs.oracle.com/javaee/6/javaserverfaces/2.1/docs/vdldocs/facelets/.
The following example shows a composite component that accepts an email address as input:
This content will not be displayed
Note the use of cc.attrs.value when defining the value of the inputText component. The
word cc in JavaServer Faces is a reserved word for composite components. The
#{cc.attrs.attribute-name} expression is used to access the attributes defined for the
composite component’s interface, which in this case happens to be value.
The preceding example content is stored as a file named email.xhtml in a folder named
resources/emcomp, under the application web root directory. This directory is considered a
122
The Java EE 6 Tutorial • January 2013
Web Resources
library by JavaServer Faces, and a component can be accessed from such a library. For more
information on resources, see “Web Resources” on page 123.
The web page that uses this composite component is generally called a using page. The using
page includes a reference to the composite component, in the xml namespace declarations:
Using a sample composite component
The local composite component library is defined in the xmlns namespace with the declaration
xmlns:em="http://java.sun.com/jsf/composite/emcomp/". The component itself is
accessed through the em:email tag. The preceding example content can be stored as a web page
named emuserpage.xhtml under the web root directory. When compiled and deployed on a
server, it can be accessed with the following URL:
http://localhost:8080/application-name/faces/emuserpage.xhtml
Web Resources
Web resources are any software artifacts that the web application requires for proper rendering,
including images, script files, and any user-created component libraries. Resources must be
collected in a standard location, which can be one of the following.
■ A resource packaged in the web application root must be in a subdirectory of a resources
directory at the web application root: resources/resource-identifier.
■ A resource packaged in the web application’s classpath must be in a subdirectory of the
META-INF/resources directory within a web application:
META-INF/resources/resource-identifier. You can use this file structure to package
resources in a JAR file bundled in the web application. See Chapter 53, “Duke’s Forest Case
Study Example,” for an application that uses this mechanism.
The JavaServer Faces runtime will look for the resources in the preceding listed locations, in
that order.
Resource identifiers are unique strings that conform to the following format:
Chapter 5 • Introduction to Facelets
123
Web Resources
[locale-prefix/][library-name/][library-version/]resource-name[/resource-version]
Elements of the resource identifier in brackets ([]) are optional, indicating that only a
resource-name, which is usually a file name, is a required element. For example, the most
common way to specify a style sheet, image, or script is to use the library and name attributes,
as in the following tag from the guessnumber example:
This tag specifies that the default.css style sheet is in the directory web/resources/css.
You can also specify the location of an image using the following syntax, also from the
guessnumber example:
This tag specifies that the image named wave.med.gif is in the directory
web/resources/images.
Resources can be considered as a library location. Any artifact, such as a composite component
or a template that is stored in the resources directory, becomes accessible to the other
application components, which can use it to create a resource instance.
124
The Java EE 6 Tutorial • January 2013
6C H A P T E R 6
Expression Language
This chapter introduces the Expression Language (also referred to as the EL), which provides an
important mechanism for enabling the presentation layer (web pages) to communicate with the
application logic (managed beans). The EL is used by both JavaServer Faces technology and
JavaServer Pages (JSP) technology. The EL represents a union of the expression languages
offered by JavaServer Faces technology and JSP technology.
The following topics are addressed here:
■ “Overview of the EL” on page 125
■ “Immediate and Deferred Evaluation Syntax” on page 126
■ “Value and Method Expressions” on page 128
■ “Defining a Tag Attribute Type” on page 134
■ “Literal Expressions” on page 135
■ “Operators” on page 136
■ “Reserved Words” on page 136
■ “Examples of EL Expressions” on page 137
Overview of the EL
The EL allows page authors to use simple expressions to dynamically access data from
JavaBeans components. For example, the test attribute of the following conditional tag is
supplied with an EL expression that compares 0 with the number of items in the session-scoped
bean named cart.
...
JavaServer Faces technology uses the EL for the following functions:
■ Deferred and immediate evaluation of expressions
■ The ability to set as well as get data
125
Immediate and Deferred Evaluation Syntax
■ The ability to invoke methods
See “Using the EL to Reference Managed Beans” on page 191 for more information on how to
use the EL in JavaServer Faces applications.
To summarize, the EL provides a way to use simple expressions to perform the following tasks:
■ Dynamically read application data stored in JavaBeans components, various data structures,
and implicit objects
■ Dynamically write data, such as user input into forms, to JavaBeans components
■
Invoke arbitrary static and public methods
■ Dynamically perform arithmetic operations
The EL is also used to specify the following kinds of expressions that a custom tag attribute will
accept:
■
Immediate evaluation expressions or deferred evaluation expressions. An immediate
evaluation expression is evaluated at once by the underlying technology, such as JavaServer
Faces. A deferred evaluation expression can be evaluated later by the underlying technology
using the EL.
■ Value expression or method expression. A value expression references data, whereas a
method expression invokes a method.
■ Rvalue expression or lvalue expression. An rvalue expression can only read a value,
whereas an lvalue expression can both read and write that value to an external object.
Finally, the EL provides a pluggable API for resolving expressions so custom resolvers that can
handle expressions not already supported by the EL can be implemented.
Immediate and Deferred Evaluation Syntax
The EL supports both immediate and deferred evaluation of expressions. Immediate evaluation
means that the expression is evaluated and the result returned as soon as the page is first
rendered. Deferred evaluation means that the technology using the expression language can use
its own machinery to evaluate the expression sometime later during the page’s lifecycle,
whenever it is appropriate to do so.
Those expressions that are evaluated immediately use the ${} syntax. Expressions whose
evaluation is deferred use the #{} syntax.
Because of its multiphase lifecycle, JavaServer Faces technology uses mostly deferred evaluation
expressions. During the lifecycle, component events are handled, data is validated, and other
tasks are performed in a particular order. Therefore, a JavaServer Faces implementation must
defer evaluation of expressions until the appropriate point in the lifecycle.
Other technologies using the EL might have different reasons for using deferred expressions.
126
The Java EE 6 Tutorial • January 2013
Immediate and Deferred Evaluation Syntax
Immediate Evaluation
All expressions using the ${} syntax are evaluated immediately. These expressions can be used
only within template text or as the value of a tag attribute that can accept runtime expressions.
The following example shows a tag whose value attribute references an immediate evaluation
expression that gets the total price from the session-scoped bean named cart:
The JavaServer Faces implementation evaluates the expression ${sessionScope.cart.total},
converts it, and passes the returned value to the tag handler.
Immediate evaluation expressions are always read-only value expressions. The preceding
example expression cannot set the total price, but instead can only get the total price from the
cart bean.
Deferred Evaluation
Deferred evaluation expressions take the form #{expr} and can be evaluated at other phases of
a page lifecycle as defined by whatever technology is using the expression. In the case of
JavaServer Faces technology, its controller can evaluate the expression at different phases of the
lifecycle, depending on how the expression is being used in the page.
The following example shows a JavaServer Faces h:inputText tag, which represents a text field
component into which a user enters a value. The h:inputText tag’s value attribute references a
deferred evaluation expression that points to the name property of the customer bean:
For an initial request of the page containing this tag, the JavaServer Faces implementation
evaluates the #{customer.name} expression during the render-response phase of the lifecycle.
During this phase, the expression merely accesses the value of name from the customer bean, as
is done in immediate evaluation.
For a postback request, the JavaServer Faces implementation evaluates the expression at
different phases of the lifecycle, during which the value is retrieved from the request, validated,
and propagated to the customer bean.
As shown in this example, deferred evaluation expressions can be
■ Value expressions that can be used to both read and write data
■ Method expressions
Value expressions (both immediate and deferred) and method expressions are explained in the
next section.
Chapter 6 • Expression Language
127
Value and Method Expressions
Value and Method Expressions
The EL defines two kinds of expressions: value expressions and method expressions. Value
expressions can either yield a value or set a value. Method expressions reference methods that
can be invoked and can return a value.
Value Expressions
Value expressions can be further categorized into rvalue and lvalue expressions. Rvalue
expressions can read data but cannot write it. Lvalue expressions can both read and write data.
All expressions that are evaluated immediately use the ${} delimiters and are always rvalue
expressions. Expressions whose evaluation can be deferred use the #{} delimiters and can act as
both rvalue and lvalue expressions. Consider the following two value expressions:
${customer.name}
#{customer.name}
The former uses immediate evaluation syntax, whereas the latter uses deferred evaluation
syntax. The first expression accesses the name property, gets its value, adds the value to the
response, and gets rendered on the page. The same can happen with the second expression.
However, the tag handler can defer the evaluation of this expression to a later time in the page
lifecycle, if the technology using this tag allows.
In the case of JavaServer Faces technology, the latter tag’s expression is evaluated immediately
during an initial request for the page. In this case, this expression acts as an rvalue expression.
During a postback request, this expression can be used to set the value of the name property with
user input. In this case, the expression acts as an lvalue expression.
Referencing Objects Using Value Expressions
Both rvalue and lvalue expressions can refer to the following objects and their properties or
attributes:
■
JavaBeans components
■ Collections
■
Java SE enumerated types
Implicit objects
■
To refer to these objects, you write an expression using a variable that is the name of the object.
The following expression references a managed bean called customer:
${customer}
128
The Java EE 6 Tutorial • January 2013
Value and Method Expressions
The web container evaluates the variable that appears in an expression by looking up its value
according to the behavior of PageContext.findAttribute(String), where the String
argument is the name of the variable. For example, when evaluating the expression
${customer}, the container will look for customer in the page, request, session, and application
scopes and will return its value. If customer is not found, a null value is returned.
You can use a custom EL resolver to alter the way variables are resolved. For instance, you can
provide an EL resolver that intercepts objects with the name customer, so that ${customer}
returns a value in the EL resolver instead.
To reference an enum constant with an expression, use a String literal. For example, consider
this Enum class:
public enum Suit {hearts, spades, diamonds, clubs}
To refer to the Suit constant Suit.hearts with an expression, use the String literal "hearts".
Depending on the context, the String literal is converted to the enum constant automatically.
For example, in the following expression in which mySuit is an instance of Suit, "hearts" is
first converted to Suit.hearts before it is compared to the instance:
${mySuit == "hearts"}
Referring to Object Properties Using Value Expressions
To refer to properties of a bean or an enum instance, items of a collection, or attributes of an
implicit object, you use the . or [] notation.
To reference the name property of the customer bean, use either the expression
${customer.name} or the expression ${customer["name"]}. The part inside the brackets is a
String literal that is the name of the property to reference.
You can use double or single quotes for the String literal. You can also combine the [] and .
notations, as shown here:
${customer.address["street"]}
Properties of an enum constant can also be referenced in this way. However, as with JavaBeans
component properties, the properties of an Enum class must follow JavaBeans component
conventions. This means that a property must at least have an accessor method called
getProperty, where Property is the name of the property that can be referenced by an
expression.
For example, consider an Enum class that encapsulates the names of the planets of our galaxy and
includes a method to get the mass of a planet. You can use the following expression to reference
the method getMass of the Enum class Planet:
${myPlanet.mass}
Chapter 6 • Expression Language
129
Value and Method Expressions
If you are accessing an item in an array or list, you must use either a literal value that can be
converted to int or the [] notation with an int and without quotes. The following examples
could resolve to the same item in a list or array, assuming that socks can be converted to int:
■
■
${customer.orders[1]}
${customer.orders.socks}
In contrast, an item in a Map can be accessed using a string literal key; no coercion is required:
${customer.orders["socks"]}
An rvalue expression also refers directly to values that are not objects, such as the result of
arithmetic operations and literal values, as shown by these examples:
■
■
■
■
${"literal"}
${customer.age + 20}
${true}
${57}
The EL defines the following literals:
■ Boolean: true and false
■
Integer: as in Java
■ Floating-point: as in Java
■
String: with single and double quotes; " is escaped as \", ’ is escaped as \’, and \ is escaped as
\\
■ Null: null
You can also write expressions that perform operations on an enum constant. For example,
consider the following Enum class:
public enum Suit {club, diamond, heart, spade}
After declaring an enum constant called mySuit, you can write the following expression to test
whether mySuit is spade:
${mySuit == "spade"}
When it resolves this expression, the EL resolving mechanism will invoke the valueOf method
of the Enum class with the Suit class and the spade type, as shown here:
mySuit.valueOf(Suit.class, "spade"}
130
The Java EE 6 Tutorial • January 2013
Value and Method Expressions
Where Value Expressions Can Be Used
Value expressions using the ${} delimiters can be used in
■
Static text
■ Any standard or custom tag attribute that can accept an expression
The value of an expression in static text is computed and inserted into the current output. Here
is an example of an expression embedded in static text:
some text ${expr} some text
If the static text appears in a tag body, note that an expression will not be evaluated if the body is
declared to be tagdependent.
Lvalue expressions can be used only in tag attributes that can accept lvalue expressions.
A tag attribute value using either an rvalue or lvalue expression can be set in the following ways:
■ With a single expression construct:
These expressions are evaluated, and the result is converted to the attribute’s expected type.
■ With one or more expressions separated or surrounded by text:
These kinds of expression, called composite expressions, are evaluated from left to right. Each
expression embedded in the composite expression is converted to a String and then
concatenated with any intervening text. The resulting String is then converted to the
attribute’s expected type.
■ With text only:
This expression is called a literal expression. In this case, the attribute’s String value is
converted to the attribute’s expected type. Literal value expressions have special syntax rules.
See “Literal Expressions” on page 135 for more information. When a tag attribute has an
enum type, the expression that the attribute uses must be a literal expression. For example,
the tag attribute can use the expression "hearts" to mean Suit.hearts. The literal is
converted to Suit, and the attribute gets the value Suit.hearts.
All expressions used to set attribute values are evaluated in the context of an expected type. If
the result of the expression evaluation does not match the expected type exactly, a type
conversion will be performed. For example, the expression ${1.2E4} provided as the value of
an attribute of type float will result in the following conversion:
Chapter 6 • Expression Language
131
Value and Method Expressions
Float.valueOf("1.2E4").floatValue()
See Section 1.18 of the JavaServer Pages 2.2 Expression Language specification (available from
http://jcp.org/aboutJava/communityprocess/final/jsr245/) for the complete type
conversion rules.
Method Expressions
Another feature of the EL is its support of deferred method expressions. A method expression is
used to invoke an arbitrary public method of a bean, which can return a result.
In JavaServer Faces technology, a component tag represents a component on a page. The
component tag uses method expressions to invoke methods that perform some processing for
the component. These methods are necessary for handling events that the components generate
and for validating component data, as shown in this example:
The h:inputText tag displays as a text field. The validator attribute of this h:inputText tag
references a method, called validateName, in the bean, called customer.
Because a method can be invoked during different phases of the lifecycle, method expressions
must always use the deferred evaluation syntax.
Like lvalue expressions, method expressions can use the . and the [] operators. For example,
#{object.method} is equivalent to #{object["method"]}. The literal inside the [] is converted
to String and is used to find the name of the method that matches it. Once the method is found,
it is invoked, or information about the method is returned.
Method expressions can be used only in tag attributes and only in the following ways:
■ With a single expression construct, where bean refers to a JavaBeans component and
method refers to a method of the JavaBeans component:
The expression is evaluated to a method expression, which is passed to the tag handler. The
method represented by the method expression can then be invoked later.
■ With text only:
132
The Java EE 6 Tutorial • January 2013
Value and Method Expressions
Method expressions support literals primarily to support action attributes in JavaServer
Faces technology. When the method referenced by this method expression is invoked, the
method returns the String literal, which is then converted to the expected return type, as
defined in the tag’s tag library descriptor.
Parameterized Method Calls
The EL offers support for parameterized method calls. Method calls can use parameters without
having to use static EL functions.
Both the . and [] operators can be used for invoking method calls with parameters, as shown in
the following expression syntax:
■
■
expr-a[expr-b](parameters)
expr-a.identifier-b(parameters)
In the first expression syntax, expr-a is evaluated to represent a bean object. The expression
expr-b is evaluated and cast to a string that represents a method in the bean represented by
expr-a. In the second expression syntax, expr-a is evaluated to represent a bean object, and
identifier-b is a string that represents a method in the bean object. The parameters in
parentheses are the arguments for the method invocation. Parameters can be zero or more
values or expressions, separated by commas.
Parameters are supported for both value expressions and method expressions. In the following
example, which is a modified tag from the guessnumber application, a random number is
provided as an argument rather than from user input to the method call:
The preceding example uses a value expression.
Consider the following example of a JavaServer Faces component tag that uses a method
expression:
The EL expression trader.buy calls the trader bean’s buy method. You can modify the tag to
pass on a parameter. Here is the revised tag where a parameter is passed:
In the preceding example, you are passing the string ’SOMESTOCK’ (a stock symbol) as a
parameter to the buy method.
For more information on the updated EL, see http://uel.java.net/.
Chapter 6 • Expression Language
133
Defining a Tag Attribute Type
Defining a Tag Attribute Type
As explained in the previous section, all kinds of expressions can be used in tag attributes.
Which kind of expression and how it is evaluated, whether immediately or deferred, are
determined by the type attribute of the tag’s definition in the View Description Language
(VDL) that defines the tag.
If you plan to create custom tags, for each tag in the VDL, you need to specify what kind of
expression to accept. Table 6–1 shows the kinds of tag attributes that accept EL expressions,
gives examples of expressions they accept, and provides the type definitions of the attributes
that must be added to the VDL. You cannot use #{} syntax for a dynamic attribute, meaning an
attribute that accepts dynamically calculated values at runtime. Similarly, you also cannot use
the ${} syntax for a deferred attribute.
TABLE 6–1 Definitions of Tag Attributes That Accept EL Expressions
Attribute Type
Example Expression
Type Attribute Definition
Dynamic
Dynamic
"literal"
${literal}
truetrue
Deferred value
"literal"
java.lang.String
Deferred value
#{customer.age}
Deferred method
"literal"
int
java.lang.String submit()
Deferred method
#{customer.calcTotal}
double calcTotal(int, double)
In addition to the tag attribute types shown in Table 6–1, you can define an attribute to accept
both dynamic and deferred expressions. In this case, the tag attribute definition contains both
an rtexprvalue definition set to true and either a deferred-value or deferred-method
definition.
134
The Java EE 6 Tutorial • January 2013
Literal Expressions
Literal Expressions
A literal expression is evaluated to the text of the expression, which is of type String. A literal
expression does not use the ${} or #{} delimiters.
If you have a literal expression that includes the reserved ${} or #{} syntax, you need to escape
these characters as follows:
■ By creating a composite expression as shown here:
${’${’}exprA}
#{’#{’}exprB}
The resulting values would then be the strings ${exprA} and #{exprB}.
■ By using the escape characters \$ and \# to escape what would otherwise be treated as an
eval-expression:
\${exprA}
\#{exprB}
The resulting values would again be the strings ${exprA} and #{exprB}.
When a literal expression is evaluated, it can be converted to another type. Table 6–2 shows
examples of various literal expressions and their expected types and resulting values.
TABLE 6–2 Literal Expressions
Expression
Expected Type
Hi
true
42
String
Boolean
int
Result
Hi
Boolean.TRUE
42
Literal expressions can be evaluated immediately or deferred and can be either value or method
expressions. At what point a literal expression is evaluated depends on where it is being used. If
the tag attribute that uses the literal expression is defined to accept a deferred value expression,
when referencing a value, the literal expression is evaluated at a point in the lifecycle that is
determined by other factors, such as where the expression is being used and to what it is
referring.
In the case of a method expression, the method that is referenced is invoked and returns the
specified String literal. For example, the h:commandButton tag of the guessnumber application
uses a literal method expression as a logical outcome to tell the JavaServer Faces navigation
system which page to display next.
Chapter 6 • Expression Language
135
Operators
Operators
In addition to the . and [] operators discussed in “Value and Method Expressions” on
page 128, the EL provides the following operators, which can be used in rvalue expressions only:
■ Arithmetic: +, - (binary), *, / and div, % and mod, - (unary)
■ Logical: and, &&, or, ||, not, !
■ Relational: ==, eq, !=, ne, <, lt, >, gt, <=, ge, >=, le. Comparisons can be made against other
values or against Boolean, string, integer, or floating-point literals.
■ Empty: The empty operator is a prefix operation that can be used to determine whether a
value is null or empty.
■ Conditional: A ? B : C. Evaluate B or C, depending on the result of the evaluation of A.
The precedence of operators highest to lowest, left to right is as follows:
■
■
■
■
■
■
■
■
■
■
[] .
() (used to change the precedence of operators)
- (unary) not ! empty
* / div % mod
+ - (binary)
< > <= >= lt gt le ge
== != eq ne
&& and
|| or
? :
Reserved Words
The following words are reserved for the EL and should not be used as identifiers:
and
ne
ge
instanceof
or
lt
true
empty
not
gt
false
div
eq
le
null
mod
136
The Java EE 6 Tutorial • January 2013
Examples of EL Expressions
Table 6–3 contains example EL expressions and the result of evaluating them.
TABLE 6–3 Example Expressions
Examples of EL Expressions
EL Expression
${1 > (4/2)}
${4.0 >= 3}
${100.0 == 100}
${(10*10) ne 100}
${’a’ < ’b’}
${’hip’ gt ’hit’}
${4 > 3}
${1.2E4 + 1.4}
${3 div 4}
${10 mod 4}
${!empty param.Add}
Result
false
true
true
false
true
false
true
12001.4
0.75
2
False if the request parameter named Add is null or an
empty string.
${pageContext.request.contextPath}
The context path.
${sessionScope.cart.numberOfItems}
${param[’mycom.productId’]}
The value of the numberOfItems property of the
session-scoped attribute named cart.
The value of the request parameter named
mycom.productId.
${header["host"]}
The host.
${departments[deptName]}
The value of the entry named deptName in the
departments map.
${requestScope[’javax.servlet.forward.
servlet_path’]}
The value of the request-scoped attribute named
javax.servlet.forward.servlet_path.
#{customer.lName}
#{customer.calcTotal}
Gets the value of the property lName from the customer
bean during an initial request. Sets the value of lName
during a postback.
The return value of the method calcTotal of the
customer bean.
Chapter 6 • Expression Language
137
138
7C H A P T E R 7
Using JavaServer Faces Technology in Web
Pages
Web pages represent the presentation layer for web applications. The process of creating web
pages for a JavaServer Faces application includes adding components to the page and wiring
them to managed beans, validators, listeners, converters, and other server-side objects that are
associated with the page.
This chapter explains how to create web pages using various types of component and core tags.
In the next chapter, you will learn about adding converters, validators, and listeners to
component tags to provide additional functionality to components.
Many of the examples in this chapter are taken from Chapter 51, “Duke’s Bookstore Case Study
Example.”
The following topics are addressed here:
■ “Setting Up a Page” on page 139
■ “Adding Components to a Page Using HTML Tags” on page 140
■ “Using Core Tags” on page 171
Setting Up a Page
A typical JavaServer Faces web page includes the following elements:
■ A set of namespace declarations that declare the JavaServer Faces tag libraries
■ Optionally, the HTML head (h:head) and body (h:body) tags
■ A form tag (h:form) that represents the user input components
To add the JavaServer Faces components to your web page, you need to provide the page access
to the two standard tag libraries: the JavaServer Faces HTML render kit tag library and the
JavaServer Faces core tag library. The JavaServer Faces standard HTML tag library defines tags
that represent common HTML user interface components. This library is linked to the HTML
139
Adding Components to a Page Using HTML Tags
render kit at http://docs.oracle.com/javaee/6/javaserverfaces/2.1/docs/
renderkitdocs/. The JavaServer Faces core tag library defines tags that perform core actions
and are independent of a particular render kit.
For a complete list of JavaServer Faces Facelets tags and their attributes, refer to the
documentation at http://docs.oracle.com/javaee/6/javaserverfaces/2.1/docs/
vdldocs/facelets/.
To use any of the JavaServer Faces tags, you need to include appropriate directives at the top of
each page specifying the tag libraries.
For Facelets applications, the XML namespace directives uniquely identify the tag library URI
and the tag prefix.
For example, when you create a Facelets XHTML page, include namespace directives as follows:
The XML namespace URI identifies the tag library location, and the prefix value is used to
distinguish the tags belonging to that specific tag library. You can also use other prefixes instead
of the standard h or f. However, when including the tag in the page, you must use the prefix that
you have chosen for the tag library. For example, in the following web page, the form tag must
be referenced using the h prefix because the preceding tag library directive uses the h prefix to
distinguish the tags defined in HTML tag library:
The sections “Adding Components to a Page Using HTML Tags” on page 140 and “Using Core
Tags” on page 171 describe how to use the component tags from the JavaServer Faces standard
HTML tag library and the core tags from the JavaServer Faces core tag library.
Adding Components to a Page Using HTML Tags
The tags defined by the JavaServer Faces standard HTML tag library represent HTML form
components and other basic HTML elements. These components display data or accept data
from the user. This data is collected as part of a form and is submitted to the server, usually
when the user clicks a button. This section explains how to use each of the component tags
shown in Table 7–1.
140
The Java EE 6 Tutorial • January 2013
Adding Components to a Page Using HTML Tags
TABLE 7–1 The Component Tags
Tag
h:column
Functions
Rendered as
Appearance
Represents a column of data
in a data component
A column of data in an
HTML table
A column in a table
h:commandButton
Submits a form to the
application
A button
An HTML element,
where the type value can
be "submit", "reset", or
"image"
h:commandLink
Links to another page or
location on a page
An HTML
element
A hyperlink
h:dataTable
Represents a data wrapper
h:form
Represents an input form
(inner tags of the form receive
the data that will be
submitted with the form)
An HTML
element
A table that can be
updated dynamically
An HTML
![\"Duke](\"duke.waving.gif\")
"
+ "");
String username = request.getParameter("username");
if (username != null && username.length() > 0) {
RequestDispatcher dispatcher =
getServletContext().getRequestDispatcher("/response");
if (dispatcher != null) {
dispatcher.include(request, response);
}
}
out.println("");
out.close();
}
...
7
Double-click the ResponseServlet.java file to view it.
This servlet also overrides the doGet method, displaying only the response. The following
excerpt begins with the @WebServlet annotation, which specifies the URL pattern, relative to
the context root:
@WebServlet("/response")
public class ResponseServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
// then write the data of the response
String username = request.getParameter("username");
if (username != null && username.length() > 0) {
out.println("