JSF Interview Questions

It is a component-based user interface framework which works on the server side and is used for the development of web applications. In this, a well-defined programming model is provided and it also consists of rich APIs and various tag libraries. The new feature called Facelets in JSF 2 is used as its default templating system. It helps in providing components and also manages its states. Server-side validation, data conversion, internationalization support, accessibility, page navigation, extensibility are some features provided by Java Server Faces.

Following are some of the main features of Java Server Faces: –

• The behavior and presentation of the web application are clearly separated using this. Business logic and user interfaces can be written separately.
• The layering of the JSF API’s directly on the top of servlet API enables the use of various applications.
• Since Facelets are used, so it is much used for building the latest web applications.

Some of the main features of Java Server Faces are listed below: –

• It is a server-side component-based framework. Inbuilt components are provided in it.
• The implementation of the latest Facelet technology has made it the most used interface for building the web applications.
• The expression language, which represents a union of expression languages provided by JSF, is an important feature.
• HTML 5, the new standard of designing web pages is used which includes new attributes and a friendly mark up to HTML 5.
• A rich set of inbuilt tools and libraries are provided with the help of which web applications can be developed easily and rapidly.

For simple applications, the life cycle phases are automatically managed by the Java Server Faces application framework. Not only it is managed automatically, but it also allows you to manage the lifecycle phases manually. The initial stage in the life cycle of a Java Server Faces application is when the client requests for a page through HTTP and ends when the server responds the request.
The life cycle phase of a JSF application is divided into phases:

• Execute phase
• Render phase

In this, when the first request is made, then the application view is built or restored. When the other requests are made, then the other actions are performed. The execution phase is further divided into various sub-phases which are as follows:

• Restore view phase
• Apply request value phase
• Process validation phase
• Update model values phase
• Invoke application phase
• Render response phase

Various actions which are performed are- applying of request parameter values, conversions, and validations of component values, updating managed beans, etc.

In this, the view which was requested by the client is rendered as a response to its browser. In this, the output is generated in the form of HTML or XHTML because of which it can be seen in the browser. Some steps which are followed during this process are given below: –

• At the initial request by the client, an application is compiled.
• After compilation, the application is executed.
• Component tree is filled with components and manage bean properties.
• A new view is built.
• This view is then rendered.
• The component tree is destroyed.
• On subsequent requests, the component tree is rebuilt.

It is a pure java class which is a collection of the set of properties and getter-setter methods. A managed bean is used for the validation of component’s data and handling any event fired by the components. It can also work as a model for the java server faces framework. This can be used by two methods:

• Configuration into XML file
• Using annotations

The configuration of the managed bean into XML file is an older approach. Firstly, an XML file is created and then JSF provides a tag to configure the manage bean. The managed bean can also be configured with the help of annotations. In this, it automatically registers that class as a resource with JSF. Here, managed bean configuration entries are not required in the application configuration resource file. This method can be considered as an alternative to the application configuration resource file approach.

Following is a list of some scopes for a managed bean class: –

• Application (@ApplicationScoped) – every user can make use of this. It helps in interacting with a web application.
• Session (@SessionScoped) – it is present in various HTTP requests in a web application.
• View (@ViewScoped) – when a user is interacting with a single page of any web application, then this scope comes into play.
• Request (@RequestScoped) – it persists when a request is made during a single HTTP request in some web application.
• None (@NoneScoped) – it indicates that no scope is defined for that particular application.
• Custom (@CustomScoped) – it is a user-defined scope which is also nonstandard.

Following are some of the advantages of Facelets: –

• In this, the code can be reused with the help of templating and composite components.
• Functional extensibility of components and other server-side objects are provided through customization.
• Compilation time is much faster.
• The expression language is validated at compile time.
• Rendering can be done with a high performance.

Some of the features of Facelets in JSF are listed below:

• XHTML is used for the creation of web pages.
• It supports tag libraries.
• It also supports expression language.
• Templating is used for components and pages.