Menu

JSF life cycle phases

JSF life cycle phases

In JavaServer Faces (JSF), the lifecycle phases represent the sequence of steps that a JSF application goes through to process a request and render a response. Understanding these phases is crucial for developers to manage state, validate input, and update components effectively. Here’s an explanation followed by a Java example for each phase of the JSF lifecycle:

JSF life cycle phases

Explanation

  • 1.  Restore View Phase:
    • In this phase, JSF determines the view to render based on the incoming request.
    • It checks if the request includes a view identifier (javax.faces.ViewState) to restore the component tree from a previous request or to create a new one.
  • 2.  Apply Request Values Phase:
    • During this phase, JSF extracts and applies the submitted values from the request parameters to the corresponding components in the component tree.
    • Conversion and validation of input data occur in this phase, ensuring that the submitted values are of the expected type and format.
  • 3.  Process Validations Phase:
    • In this phase, JSF validates the converted input values against any validator components or validator methods defined for the components.
    • If validation fails, appropriate error messages are queued for display to the user.
  • 4.  Update Model Values Phase:
    • During this phase, JSF updates the model values (managed bean properties) with the validated and converted values from the components.
    • The managed bean properties are updated based on the components’ value attributes and their corresponding setter methods.
  • 5.  Invoke Application Phase:
    • In this phase, JSF invokes application-level logic or action methods defined in the managed beans.
    • Action methods associated with UI components (like <h:commandButton> or <h:commandLink>) are executed to handle business logic, process data, or navigate to other views.
  • 6.  Render Response Phase:
    • The final phase where JSF renders the response to the client.
    • It creates the HTML output corresponding to the current state of the component tree, incorporating any updates made during the earlier phases.
    • The rendered HTML is then sent to the client’s browser for display.

Java Example

Here’s an example demonstrating the JSF lifecycle phases in action:

Managed Bean (LifecycleBean.java)
java
package com.example.beans;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;

@ManagedBean
@RequestScoped
public class LifecycleBean {

    private String inputText;

    public String getInputText() {
        return inputText;
    }

    public void setInputText(String inputText) {
        this.inputText = inputText;
    }

    public void processInput() {
        System.out.println("Input received: " + inputText);
        // Additional business logic or data processing can be performed here
    }
}

JSF Page (lifecycle.xhtml)
xml
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
    <title>JSF Lifecycle Example</title>
</h:head>
<h:body>
    <h:form>
        <h:outputLabel for="inputField" value="Enter Text:" />
        <br/>
        <h:inputText id="inputField" value="{lifecycleBean.inputText}" required="true" />
        <h:message for="inputField" style="color: red;" />
        <br/>
        <h:commandButton value="Submit" action="{lifecycleBean.processInput}" />
    </h:form>
</h:body>
</html>

Explanation of Example

  • Managed Bean (LifecycleBean.java):  This managed bean (LifecycleBean) is request-scoped and includes a property inputText. It also contains a method processInput() which is invoked during the Invoke Application Phase ({lifecycleBean.processInput}).
  • JSF Page (lifecycle.xhtml):  This JSF page (lifecycle.xhtml) includes an <h:inputText> component bound to inputText property of LifecycleBean. The <h:commandButton> triggers processInput() method defined in LifecycleBean when clicked.

Lifecycle Phases:

When the user submits the form in lifecycle.xhtml

  • Restore View Phase:  JSF initializes or restores the view.
  • Apply Request Values Phase:  Input values are extracted from the request and applied to components.
  • Process Validations Phase:  Input values are validated (if required=”true” is set).
  • Update Model Values Phase:  Validated values are updated in LifecycleBean.inputText.
  • Invoke Application Phase:  processInput() method in LifecycleBean is invoked to handle business logic.
  • Render Response Phase:  The updated view is rendered and sent back to the client.

Understanding and effectively managing the JSF lifecycle phases ensures proper handling of state, validation, and business logic within JSF applications, providing a robust and interactive user experience.

Homepage

Readmore