This article will take you through the basics of Java Server Faces. Later we will have samples which will elaborate the features and functionalities of Java Server Faces.

Java Server Faces (hereafter JSF) is an event based development framework in Java EE 5 arena. It is a framework for building user interfaces for Web application.
JSF uses the existing user interface and Web tier mechanisms but it does not tie up the applications to a particular mark-up language, protocol and client device. It encapsulates various UI component functionality enabling it to render data to various client devices by developing required custom tags. JavaServer Faces technology provides a custom renderer and a JSP custom tag library for rendering to an HTML client, allowing developers of Java EE applications to use JavaServer Faces technology in their applications.

JSF follows a MVC architecture, Web application following MVC architecture are best developed using JSF.
Let us briefly understand what is a MVC architecture. Any Enterprise Application has a Business component, Presentation component and a Controller component. Usually small applications will have all the components tightly coupled with each other. Any change to one component will have an effect on others. As the size of the application increases it becomes more difficult and complex to debug and modify the application. So as to solve this problem we need to improve the architectural design of the application.

Model(M), View(V) and Controller(C) is one step forward towards improving the application design.

Model - handles data and logic of the application. It handles the business component of the application.

View - takes care of the user interface. It handles the output of the application that has to be displayed to the user. It handles the presentation component.

Controller - handles the input from user and modifies the model or view according to the user input. A controller selects the next view that has to be displayed on the basis of the user input and outcome of the model operations.

By following a MVC architecture there is a division of functionalities among Model, View and Architecture. This model has got the following advantages:

Helps to reduce duplication in the code

Maintenance of the existing code becomes easier

Provides a central place to control all the user views- Controller

Any new user view can be added and later wired to the controller

Debugging the application becomes quite easier

Changes to the Model have a minimal effect on View and Controller

Coming back to JSF now, JSF technology clearly separates presentation logic from the application logic. Several development roles can be created and designated during the application development state. The JSF technology is developed through Java Community Process under JSR-127.

JSF has the following as the major components:

User Interface Components - These are stateful objects which are built over JavaBeans. Each UI component has associated events, properties and methods. These components reside on server side rather than on the client side (for example swing components). In JSF, UI components are rendered for the browser. For any user request components output the HTML, which is then rendered and shown to the user as GUI elements.

Navigation - JSF defines a very effective navigation system. For a given page the navigation rules defines what are the valid outcomes and which page to load for each output.

Renderer - This component is used to render UI components. This component can provide different rendering options depending on different types of browser (for example, Netscape, Internet explorer, Mozilla, Firefox). A renderer translates the user input to values which are understandable by components and vice versa.

Converter - A converter converts data from one type to another. The converted in JSF converts user inputs to components and vice versa.

Validator - A validator validates the user input and verifies whether the input is in acceptable format. In the conventional Web development validation is taken care by scripting languages like Java Script and that puts a considerable overhead over the application. JSF provides the controller mechanism which validates the input. Validation is done at the UI component level as well as the bean level.

JavaBeans - In JSF Java Beans define the interaction between UI component and model. They play the role of Controllers in JSF. We can say that Backing Bean controls the form and the components associated with the form.