JSF : Life Cycle

When the client submits a page, the JavaServer Faces implementation performs several tasks, such as validating the data input of components in the view and converting input data to types specified on the server side. The JavaServer Faces implementation performs all these tasks as a series of steps in the JavaServer Faces request-response life cycle.  During the life cycle, the JavaServer Faces implementation must build the view while considering state saved from a previous submission of the page. The phases are:

  • Restore View
  • Apply Request Values
  • Process Validations
  • Update Model Values
  • Invoke Application
  • Render Response

jsfIntro-lifecycle

The above Life-cycle Phases are not sequential. For example, the control may be re-directed to Render Response Phase from Process Validation phase in case of any Conversion or Validation Errors. The life cycle handles both kinds of requests: initial requests and postbacks. When a user makes an initial request for a page, he or she is requesting the page for the first time. When a user executes a postback, he or she submits the form contained on a page that was previously loaded into the browser as a result of executing an initial request. When the life cycle handles an initial request, it only executes the restore view and render response phases because there is no user input or actions to process. Conversely, when the life cycle handles a postback, it executes all of the phases.
You can use a PhaseListener to trace the phases of the JSF lifecycle and execute some processes where required. Lets use a  PhaseListener to debug the phases to see what is happening in which phase. Lets build on our previous jsf app. LifeCycleListener.java:


package mynotes.jsf.util;

import javax.faces.event.PhaseEvent;
import javax.faces.event.PhaseId;
import javax.faces.event.PhaseListener;

public class LifeCycleListener implements PhaseListener{

private static final long serialVersionUID = 1L;

@Override
 public void afterPhase(PhaseEvent pe) {
 System.out.println("After Phase: " + pe.getPhaseId().toString() + " invoked.");
 }

@Override
 public void beforePhase(PhaseEvent pe) {
 System.out.println("Before Phase: " + pe.getPhaseId().toString() + " invoked.");
 }

@Override
 public PhaseId getPhaseId() {
 return PhaseId.ANY_PHASE;
 }

}

Adding this to faces-config.xml:


<lifecycle>
 <phase-listener>mynotes.jsf.util.LifeCycleListener</phase-listener>
</lifecycle>

When the url [http://localhost:8080/MyNotes_JSF/pages/registration.xhtml] is hit for the first time, following output comes in console –


Before Phase: RESTORE_VIEW 1 invoked.
After Phase: RESTORE_VIEW 1 invoked.
Before Phase: RENDER_RESPONSE 6 invoked.
After Phase: RENDER_RESPONSE 6 invoked.

This is because for initial request other phases are skipped. Lets submit the page and check the output:


Before Phase: RESTORE_VIEW 1 invoked.
After Phase: RESTORE_VIEW 1 invoked.
Before Phase: APPLY_REQUEST_VALUES 2 invoked.
After Phase: APPLY_REQUEST_VALUES 2 invoked.
Before Phase: PROCESS_VALIDATIONS 3 invoked.
After Phase: PROCESS_VALIDATIONS 3 invoked.
Before Phase: UPDATE_MODEL_VALUES 4 invoked.
After Phase: UPDATE_MODEL_VALUES 4 invoked.
Before Phase: INVOKE_APPLICATION 5 invoked.
Inside register
Name=>Dhananjay
Email=>asd@ad.asd
After Phase: INVOKE_APPLICATION 5 invoked.
Before Phase: RENDER_RESPONSE 6 invoked.
After Phase: RENDER_RESPONSE 6 invoked.

Before we on to detail about each phases, note that here we are listning to phases on all componenets. You can specifically listen to phases on an invidual component also – JSF <f:phaseListener> tag is used to add the PhaseListener to the component inside which it is nested. A PhaseListener is a listener of JSF lifecycle. It implements all the phases of JSF lifecycle. Can add

@ManagedBean(name=“somename”)
@RequestScoped

over the listner and then use it inside components.

Restore View Phase

RestoreView is the first phase in the JSF lifecycle. This phase is used for constructing view to display in the front end. During this phase, the JavaServer Faces implementation builds the view of the page, wires event handlers and validators to components in the view, and saves the view in the FacesContext instance, which contains all the information needed to process a single request. All the application’s component tags, event handlers, converters, and validators have access to the FacesContext instance.

If the request for the page is an initial request, the JavaServer Faces implementation creates an empty view during this phase and the life cycle advances to the render response phase, during which the empty view is populated with the components referenced by the tags in the page.

If the request for the page is a postback, a view corresponding to this page already exists. During this phase, the JavaServer Faces implementation restores the view by using the state information saved on the client or the server.

Every view has it’s own view id and it is stored in the FacesContext’s session object. JSF View is collection of components associated with its current state. There is two types of state saving mechanism,

  1. Server (default)
  2. Client

Default value is server. If you specify state saving method as server, the state of each components will be stored in the server. If it is client, it will be stored in the client side as hidden variables. This value is configured using javax.faces.STATE_SAVING_METHOD parameter name in your web.xml context params as follows:

<context-param></pre>
<pre>    <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
    <param-value>client</param-value>
</context-param></pre>

 

Apply Request Values Phase

In this phase, the values that are entered by the user will be updated on each and every individual component defined in the View graph. More specifically, the processDecodes() on the UIComponentBase method will be called for all components. Here, the process of applying the Request values to the UI Components is called Decoding. The value is then stored locally on the component. If the conversion of the value fails, an error message associated with the component is generated and queued on FacesContext. This message will be displayed during the render response phase, along with any validation errors resulting from the process validations phase.

  • If any decode methods or event listeners called renderResponse on the current FacesContext instance, the JavaServer Faces implementation skips to the render response phase.
  • If events have been queued during this phase, the JavaServer Faces implementation broadcasts the events to interested listeners.
  • If some components on the page have their immediate attributes (see The immediate Attribute) set to true, then the validation, conversion, and events associated with these components will be processed during this phase.
  • At this point, if the application needs to redirect to a different web application resource or generate a response that does not contain any JavaServer Faces components, it can call FacesContext.responseComplete.

At the end of this phase, the components are set to their new values, and messages and events have been queued.

Process Validations Phase

During this phase, the JavaServer Faces implementation processes all validators registered on the components in the tree. JSF Implementation will traverse over the UIViewRoot to fetch all the child components and ask the child components to validate themselves by calling the method UIComponentBase.processValidators(). It examines the component attributes that specify the rules for the validation and compares these rules to the local value stored for the component.

  • If the local value is invalid, the JavaServer Faces implementation adds an error message to the FacesContext instance, and the life cycle advances directly to the render response phase so that the page is rendered again with the error messages displayed.
  • If there were conversion errors from the apply request values phase, the messages for these errors are also displayed.
  • If any validate methods or event listeners called renderResponse on the current FacesContext, the JavaServer Faces implementation skips to the render response phase.
  • At this point, if the application needs to redirect to a different web application resource or generate a response that does not contain any JavaServer Faces components, it can call FacesContext.responseComplete. If events have been queued during this phase, the JavaServer Faces implementation broadcasts them to interested listeners.

Update Model Values Phase

After the JavaServer Faces implementation determines that the data is valid, it can walk the component tree and set the corresponding server-side object properties to the components’ local values. The JavaServer Faces implementation will update only the bean properties pointed at by an input component’s value attribute. If the local data cannot be converted to the types specified by the bean properties, the life cycle advances directly to the render response phase so that the page is rerendered with errors displayed. This is similar to what happens with validation errors. At this point, if the application needs to redirect to a different web application resource or generate a response that does not contain any JavaServer Faces components, it can call FacesContext.responseComplete.

Invoke Application Phase

During this phase, the JavaServer Faces implementation handles any application-level events, such as submitting a form or linking to another page.

At this point, if the application needs to redirect to a different web application resource or generate a response that does not contain any JavaServer Faces components, it can call FacesContext.responseComplete.

If the view being processed was reconstructed from state information from a previous request and if a component has fired an event, these events are broadcast to interested listeners.

Render Response Phase

During this phase, the JavaServer Faces implementation delegates authority for rendering the page to the JSP container if the application is using JSP pages. If this is an initial request, the components represented on the page will be added to the component tree as the JSP container executes the page. If this is not an initial request, the components are already added to the tree so they needn’t be added again. In either case, the components will render themselves as the JSP container traverses the tags in the page.

If the request is a postback and errors were encountered during the apply request values phase, process validations phase, or update model values phase, the original page is rendered during this phase. If the pages contain message or messages tags, any queued error messages are displayed on the page.

After the content of the view is rendered, the state of the response is saved so that subsequent requests can access it and it is available to the restore view phase.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: