IMMEDIATE ATTRIBUTE OF JSF COMPONENT

In this blog we will see the impact of the “immediate” attributes in the life cycle of a JSF page.

And also discuss the scenarios where the “immediate” attributes can be used.

“immediate” is one of the property of JSF component. It holds Boolean value. By default it is 'false'. But when you set the immediate ="true" to any component its conversation,validation and updation of model happens in the second phase of the JSF life cycle(apply request phase). For all those component who are not set immediate="true" follow the same life cycle process.

If the component is action component  then “invoke application phase” operation is performed in the 'apply request phase'.

 Before we start  let see the  life cycle phases of any JSF page.

The JSF page life cycle has six phase:-

1. Restore View Phase

2. Apply request Phase

3. Process validation Phase

4. Update model phase

5. Invoke application phase

6.     Render response phase

Here is the example for immediate attributes :-

Backing Bean :-

Html page :-

Flow without “immediate=true” :-

1.     Restore View :- The View  is restored  from the session.

2.     Apply Request :-  The submitted  form values are store in the relevant component in the UIViewRoot. In this case the “name” enter by the user is store in the name component.The value is then converted into the data type of the property. In this case “name” is of String type, so the it is mapped into String. If name was Integer then value is converted into the Integer type.

3.     Process Validation :- The value store in the component is validated.

4.     Update Model  :-  After confirming that data is valid in the previous phase local values of components can be set to corresponding server side object properties i.e. backing beans. So bean properties will be updated .In this case the “name” property of the “ImmediateSampleBean” is updated.

5.     Invoke Application :-The components values are converted , validated and updated. In this phase the business logic is executed. In this case the “action” method of the “ImmediateSampleBean” backing bean is executed.

6.     Render Response :-In this phase JSP container renders the page back to the user  i.e. view is displayed with all of its components in their current state.

Flow with “immediate=true” set  for input :-

If set the immediate=”true” to the inputText for the name then. Validation and Converstion of the submitted value for the “name” input will happen in the second phase of the page Life cycle.

1.     Restore View :- The View  is restored  from the session.

2.     Apply Request :-  The submitted  form values are store in the relevant component in the UIViewRoot. In this case the “name” enter by the user is store in the name component. The Conversation and Validation of the submitted value happens in this phase. If any error occurs then the message is displayed and controls goes to the Render Response Phase.

3.     Process Validation :- Nothing happens here.

4.     Update Model :-  Backing bean properties will be updated . 

5.     Invoke Application :- The components values are converted , validated and updated. In this phase the business logic is executed.

6.     Render Response :- The Page is render back to the user with updated values.

Note :-  many people believe that “immediate” is used to skip the validation. But validation happens. The difference is that validation happens in the earlier phase.

 For example :- If we do not pass any value to the input component then the error message “Name is required” is displayed.

For above code if user don't provide any value and click the "action" button then following error message is displayed in the screen.

The Life cycle will be like

Flow with “immediate=true” set for CommandButton :-

If set the immediate=”true” to the “commandButton” then the action is performed in the “Apply Request Phase” rather than waiting for the “Invoke Application Phase”.

1.     Restore View :- The View  is restored  from the session.

2.     Apply Request :- The submitted  form values are store in the relevant component in the UIViewRoot. In this case the “name” enter by the user is store in the name component. The real processing of the form submission happens here. This happens in this phase instead of the Invoke application phase due to the immediate="true" in the h:commandButton. The UIInput components which don't have immediate="true" set will not be converted, validated nor updated

3.     Process Validation :-This phase is skipped due to the immediate="true" in the h:commandButton.

4.     Update Model :- This phase is skipped due to the immediate="true" in the h:commandButton.

5.     Invoke Application :- This phase is skipped due to the immediate="true" in the h:commandButton.

6.     Render Response :-  The Page is render back to the user.

Note :-  As the “Update Model Phase” is skipped the submitted values are not updated. So nothing will be displayed in the outputText.

Flow with “immediate=true” set for both InputText and CommandButton :-

If set the immediate=”true” to the “commandButton” then the action is performed in the “Apply Request Phase” rather than waiting for the “Invoke Application Phase”. Also  for the properties which are set  immediate=”true”, the conversation , validation and updation of the model values happens in this phase only.

1.     Restore View  :-  The View  is restored  from the session.

2.     Apply Request  :-   The submitted  form values are store in the relevant component in the UIViewRoot. In this case the “name” enter by the user is store in the name component.The conversation , validation and updation of model values happens in this phase for components which are set immediate=”true”. In this case “name”. Then the business logic is executed that is action method is called.

  

3.     Process Validation :- This phase is skipped due to the immediate="true" in the h:commandButton.

4.     Update Model :- This phase is skipped due to the immediate="true" in the h:commandButton.

5.     Invoke Application :- This phase is skipped due to the immediate="true" in the h:commandButton.

6.     Render Response:- The Page is render back to the user with updated values.

JSF Component

JSF Components

For next few blogs we will be discussing on In build Jsf component. How these component can be used in the application and the attributes they support. We will also see how to create custom and composite tags. But before we start let us see what really a component is.

Jsf is a component driven framework. A component is a unit which perform a specific task and can be can be deployed independently and is subject to composition by third parties. “A Jsf UI component, or control, is a component that provides specific functionality for interacting with an end user. Classic examples include toolbars, buttons, panels, and calendars”.

A jsf Component fuctionality can be discribe in three steps:-

1. Converting incoming request parameters from the markup(Html) to the values of the component.
2. Hold the values for process like converstion , validation and bussiness logic action.
3. Converting the current values of the component back into the corresponding markup, that is, HTML.

Thus JSF components consist of two parts: the component and the renderer.

The JSF Component class defines the state and behavior of a UI component; a renderer defines how the component will be read from the request and how it will be displayed -- usually though HTML.The renderer converts the values of the component to appropriate markup. Event queuing and performance validation happen inside the component.

Let us look take an example . The HtmlInputText component can be divded into two parts

1. <h:inputText> tag which is responsible for holding the information and behavior .
2. A TextRenderer which is reponsible for Decoding the request from html to component value and encoding the component values into html standards.

In Jsf Life Cycle you can see the phase where the encoding and decoding happens.

JSF Tags

JSF application typically uses JSP pages to represent views. JSF provides useful special tags to enhance these views. Each tag gives rise to an associated component. JSF provides 43 tags in two standard JSF tag libraries:

1. JSF Core Tags Library and
2. JSF Html Tags Library

Even a very simple page uses tags from both libraries.

<%@ taglib uri=”http://java.sun.com/jsf/core“ prefix=”f” %>
<%@ taglib uri=”http://java.sun.com/jsf/html“ prefix=”h” %>

Here we will see the Jsf Html Tags Libraries . We will discuss the Jsf core libraries in the further blogs.

JSF Html Tags:

Jsf Html tags can be divided into following categories:

1. Inputs :
     inputText :- creates text input control (single line)
     inputTextarea :- creates text input control (multiline)
     inputHidden :- creates hidden field
       inputSecret :- creates input control for password

2. Outputs :
       outputFormat :- creates outputText, but formats compound     messages
      outputLabe l:- creates label
      outputLink :- creates anchor
      outputText :- creates single line text output 

3. Commands :
       commandButton:- creates button
       commandLink:- creates link that acts like a pushbutton

4. Selections : 
       selectBooleanCheckbox :- creates checkbox
       selectManyCheckbox:- creates set of checkboxes
       selectManyListbox :- creates multiselect listbox
      selectManyMenu:- creates multiselect menu
       selectOneListbox:- creates single select listbox
       selectOneMenu:- creates single select menu
       selectOneRadio:- creates set of radio buttons

5.  Layouts :

       form :- creates a form

       panelGrid :- creates html table with specified number of columns

       panelGroup :- used to group other components where the specification 

                         requires one child element.   

6. Data Table :
      dataTable:- creates a table control
       column:- creates column in a dataTable

7.  Message :
        message:- displays the most recent message for a component
        messages:- displays all messages

Java Server faces (JSF) page life cycle

The Life Cycle of a JSF Page

The Jsf page lifeCycle is similar to any other servlet page. Client make a request and the server gives response with page converted into html. Now JSF offers additional features which effect the processing of the page.

The knowledge of jsf page lifecycle helps the developers handle the process like conversation, validation ,event handling.

Now before we go to the jsf life cycle let us take a brief look at the JSF framework.

Jsf is a framework which follows MVC(Model,View, Controller) design pattern.

1. The Controller serves as an intermediary between the Model, the View, and any other resources needed to process the HTTP request and generate a web page.
2. The Model represents your data structures. Typically your model classes will contain functions that help you retrieve, insert, and update information in your your database.
3. A JavaServer Faces page is represented by a tree of UI components, called a view. The View is the information that is being presented to a user.
   The Java Server Faces(JSF) page life cycle start with the request from the browser , the processing happens with interaction between the Model, View and Controller and cycle ends with response to the browser.
   
   
   The JSF page life cycle has six phase:-
   1. Restore View Phase
   2. Apply request Phase
   3.Process validation Phase
   4.Update model phase
   5.Invoke application phase
   6.Render response phase

1. Restore View Phase :-

When a request for a JavaServer Faces page is made, such as when a link or a button is clicked, the JavaServer Faces implementation begins the restore view phase.

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. The FacesContext instance 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. The empty view will be populated when the page is processed during a postback.

2. Apply request Phase :-

After the component tree is restored, each component in the tree extracts its new value from the request parameters by using its decode method. 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 an 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 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.

3. Process validation Phase :-

During this phase, the JavaServer Faces implementation processes all validators registered on the components in the tree. 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 therender 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.

4.Update model 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.

If any updateModels methods or any listeners called renderResponse on the current FacesContext instance, 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

 5. 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.

6.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.

Introduction

Hi ,
I am Gautam Balwant Singh . I am a java software devleoper.
Had got enough experience to guide help and guide others in various java technologies.
Time to time I will be sharing my knowledge using this blog as a medium.
Please fell free to post for queries regarding java technologies.