This Wiki page is for questions about the JavaServer Faces Specification. Questions about Oracle's implementation of JSF are covered at The Mojarra FAQ.
Table of Contents:
JavaServer Faces technology is a framework for building user interfaces for web applications. JavaServer Faces technology includes:
With the simple, well-defined programming model that JavaServer Faces technology provides, developers of varying skill levels can quickly and easily build Web applications by: assembling reusable UI components in a page, connecting these components to an application data source, and wiring client-generated events to server-side event handlers. With the power of JavaServer Faces technology, these web applications handle all of the complexity of managing the user interface on the server, allowing the application developer to focus on their application code.
The primary benefits of JavaServer Faces technology include:
Because of the extensibility and ease-of-use that JavaServer Faces technology provides, a wide range of developers and web-page designers can take advantage of the power of JavaServer Faces technology. These users include:
A number of important industry players are collaborating with Sun to define the first draft of the JavaServer Faces specification. Please see JSR-252 for a complete list of expert group members.
JavaServerFaces is a JCP specification. The sponsoring organization of the specification has chosen to use java.net to help make the development process transparent. Here are two avenues for involvement.
The issuetracker of record for the JavaServer Faces specification is at <http://jsf.java.net/issues/ >.
Struts is an open-source Java web application framework whose architecture is based on the Model-View-Controller design pattern in which requests are routed through a controller that provides overall application management and dispatches the requests to application components. JavaServer Faces technology is a user-interface framework for Java web applications. It is focussed on the view tier of an MVC-based architecture. The Struts and JavaServer Faces technology frameworks do have some overlapping functionality; however each framework has its advantages, and developers can use certain features of both frameworks in a single application.
The primary advantages of Struts as compared to JavaServer Faces technology are as follows:
The greatest advantage that JavaServer Faces technology has over Struts is its flexible, extensible UI component model, which includes:
Because the JavaServer Faces technology architecture separates the definition of a component from its rendering, you can render your components in different ways or even to different clients, such as a WML client. Moreover, the extensible component APIs of JavaServer Faces technology allow you to extend the standard set of components and create entirely new components. None of this is possible with Struts. In fact, Struts has no notion of server-side components, which also means that it has no event model for responding to component events and no facility for saving and restoring component state. While Struts does have a useful tag library for rendering components on the page, these components have no object representation on the server and they can only be rendered to an HTML client.
Another distinct advantage of JavaServer Faces technology is that it is standard, which means that it has been developed through the Java Community Process (JCP) and has been designed to allow easy integration into tools. As a result, JavaServer Faces technology already has wide industry support and is being leveraged by several web application development IDEs (such as Sun Java Studio Creator).
Because both JavaServer Faces technology and Struts contribute such valuable features, developers might want to be able to use both of them in a single application. Developers might want to integrate the flexible component model of JavaServer Faces technology into their existing Struts applications while continuing to use the Struts controller architecture. Similarly, developers who have JavaServer Faces technology applications might want to integrate the more powerful client-side validation mechanism and Tiles layout framework found in the Struts architecture into their applications. These goals can be accomplished by using the stuts-faces integration library, which you can download from here.
For more information on the relationship of Struts and JavaServer Faces technology, see Craig McClanahan's blog entry on this topic.
JavaServer Faces technology, version 1.0 relies on JSP 1.2. Since JSP 2.0 is a superset of JSP 1.2, it is possible to use JavaServer Faces technology, version 1.0 with JSP 2.0. JSF 2.0 supports JSP only as a backwards compatability techtnology, and uses Facelets as its preferred View Declaration Language.
JSF 1.1 Troubleshooting Questions
The forEach tag does not work with JavaServer Faces technology, version 1.0 and 1.1 tags due to an incompatibility between the strategies used by JSTL and and JavaServer Faces technology. Instead, you could use a renderer, such as the Table renderer used by the dataTable tag, that performs its own iteration. The if, choose and when tags work, but the JavaServer Faces tags nested within these tags must have explicit identifiers.
This shortcoming has been fixed in JSF 1.2.
When I use <c:import> or <jsp:include> to include content from a a JSP page into a JavaServer Faces page, it produces incorrect HTML output. Why does this happen?
When using <jsp:include> or <c:import> to compose a single view from multiple JSP pages, all JavaServer Faces component tags in the included pages must be nested inside the <f:subview> tag the JavaServer Faces core tag library (which is itself nested inside the <f:view> tag). The <f:subview>
tag itself can be present in the including page with the <jsp:include> or <c:import> tag nested inside it, or it can be in the included page.
JSF 1.2 Troubleshooting Questions
A new feature of JSP 2.1, called JSP Id Consumer allows these tags to work as expected.
This has been fixed in JSF 1.2
Absolutely! We use ##jsf on irc.freenode.net. Converse with members of the team working on JavaServer Faces technology by joining our public chat room on freenode.net. After you access freenode with your IRC client for the first time, you register yourself with the following command:
The password should be one that you don't mind others accessing. In other words, don't use a password that you already use for something else important.
Finally, after you've registered your password or identified yourselfe, you join the channel:
(Note the two ##). Happy chatting!
Absolutely! We use #jsfaces on Sun's internal IRC network. Change the domain name to irc.<yourdomain>.sun.com where yourdomain is east, sfbay, central, etc. Converse with members of the team working on JavaServer Faces technology by joining our public chat room on Sun's Intranet. After you access freenode with your IRC client for the first time, you join the channel with the following command:
Here is a wiki page that collects links to real world sites using JSF.