Home | Download | PDF | API | FAQ | Search | Feedback | History

> ## Backing Beans

> A typical JavaServer Faces application includes one or more backing beans, each of which is a JavaServer Faces managed bean that is associated with the UI components used in a particular page. Managed beans are JavaBeans components (see JavaBeans Components, page 131) that you can configure using the managed bean facility, which is described in Configuring Beans, page 451.

> This section introduces the basic concepts on creating, configuring, and using backing beans in an application. All backing beans are configured in the application's configuration file using the managed bean facility. Page authors use the unified expression language to refer to backing bean properties and methods from component tags on a page.

> #### Backing Bean Class

> In addition to defining a no-arg constructor, as all JavaBeans components must do, a backing bean class also defines a set of UI component properties and possibly a set of methods that perform functions for a component.

> Each of the component properties can be bound to one of the following:

> - A component's value
> - A component instance
> - A converter instance
> - A listener instance
> - A validator instance

> The most common functions that backing bean methods perform include the following:

> - Validating a component's data
> - Handling an event fired by a component
> - Performing processing to determine the next page to which the application must navigate.

> As with all JavaBeans components, a property consists of a private data field and a set of accessor methods, as shown by this code from the Guess Number example:

>     Integer userNumber = null;
>     ...
>     public void setUserNumber(Integer user_number) {
>       userNumber = user_number;
>     }
>     public Integer getUserNumber() {
>       return userNumber;
>     }
>     public String getResponse() {
>       ...
>     }

> Because backing beans follow JavaBeans component conventions, you can reference beans you've already written from your JavaServer Faces pages.

> When a bean property is bound to a component's value, it can be any of the basic primitive and numeric types or any Java object type for which the application has access to an appropriate converter. For example, a property can be of type `Date` if the application has access to a converter that can convert the `Date` type to a String and back again. See Writing Bean Properties (page 380) for information on which types are accepted by which component tags.

> When a bean property is bound to a component instance, the property's type must be a the same as the component object. For example, if a `UISelectBoolean` is bound to the property, the property must accept and return a `UISelectBoolean` object.

> Likewise, if the property is bound to a converter, validator, or listener instance then the property must be of the appropriate converter, validator, or listener type.

> For more information on writing beans and their properties, see Writing Bean Properties (page 380).

> #### Configuring a Bean

> JavaServer Faces technology supports a sophisticated managed bean creation facility, which allows application architects to do the following:

> - Configure simple beans and more complex trees of beans
> - Initialize bean properties with values
> - Place beans in a particular scope
> - Expose the beans to the unified EL so that page authors can access them.

> An application architect configures the beans in the application configuration file use XML elements, as shown by this example from Guess Number:

>     <managed-bean>
>       <managed-bean-name>UserNumberBean</managed-bean-name>
>       <managed-bean-class>
>         guessNumber.UserNumberBean
>       </managed-bean-class>
>       <managed-bean-scope>session</managed-bean-scope>
>       <managed-property>
>         <property-name>minimum</property-name>
>         <property-class>long</property-class>
>         <value>0</value>
>       </managed-property>
>       <managed-property>
>         <property-name>maximum</property-name>
>         <property-class>long</property-class>
>         <value>10</value>
>       </managed-property>
>     </managed-bean>

> The JavaServer Faces implementation processes this file on application startup time. When `UserNumberBean` is first referenced from the page, the JavaServer Faces implementation initializes it and sets the values of the properties, `maximum` and `minimum`. The bean is then stored in session scope if no instance exists. As such, the bean is available for all pages in the application.

> A page author can then access the bean properties from the component tags on the page using the unified EL, as shown here:

>     <h:outputText value="#{UserNumberBean.minimum}"/>

> The part of the expression before the . matches the name defined by the `managed-bean-name` element. The part of the expression after the . matches the name defined by the `property-name` element corresponding to the same `managed-bean` declaration.

> Notice that the application configuration resource file does not configure the `userNumber` property. Any property that does not have a corresponding `managed-property` element will be initialized to whatever the constructor of the bean class has the instance variable set to.The next section explains more about using the unified EL to reference backing beans.

> For more information on configuring beans using the managed bean creation Facility, see Configuring Beans (page 451).

> #### Using the Unified EL to Reference Backing Beans

> To bind UI component values and objects to backing bean properties or to reference backing bean methods from UI component tags, page authors use the unified expression language (EL) syntax defined by JSP 2.1. As explained in Unified Expression Language (page 108), some of the features this language offers are:

> - Deferred evaluation of expressions
> - The ability to use a value expression to both read and write data.
> - Method expressions

> These features are all especially important for supporting the sophisticated UI component model offered by JavaServer Faces technology.

> Deferred evaluation of expressions is important because the JavaServer Faces life cycle is split into separate phases so that component event handling, data conversion and validation, and data propagation to external objects are all performed in an orderly fashion. The implementation must be able to delay the evaluation of expressions until the proper phase of the life cycle has been reached. Therefore, its tag attributes always use deferred evaluation syntax, which is distinguished by the `#{}` delimiters.The Life Cycle of a JavaServer Faces Page describes the life cycle in detail.

> In order to store data in external objects, almost all JavaServer Faces tag attributes use lvalue value expressions, which are expressions that allow both getting and setting data on external objects.

> Finally, to invoke methods that can handle component events, validation, and conversion, some select tag attributes accept method expressions that reference these methods.

> To illustrate a JavaServer Faces tag using the unified EL, let's suppose that the `userNo` tag of the `guessNumber` application referenced a method that performed the validation of user input rather than using `LongRangeValidator`:

>     <h:inputText id="userNo"
>       value="#{UserNumberBean.userNumber}"
>       validator="#{UserNumberBean.validate}" />

> This tag binds the `userNo` component's value to the `UserNumberBean.userNumber` backing bean property using an lvalue expression. It uses a method expression to refer to the `UserNumberBean.validate` method, which performs validation of the component's local value. The local value is whatever the user enters into the field corresponding to this tag. This method is invoked when the expression is evaluated, which is during the process validation phase of the life cycle.

> Nearly all JavaServer Faces tag attributes accept value expressions. In addition to referencing bean properties, value expressions can also reference lists, maps, arrays, implicit objects, and resource bundles.

> Another use of value expressions is binding a component instance to a backing bean property. A page author does this by referencing the property from the `binding` attribute:

>     <inputText binding="#{UserNumberBean.userNoComponent}" />

> Those component tags that use method expressions are `UIInput` component tags and `UICommand` component tags. See sections Using Text Components (page 321) and Using Command Components for Performing Actions and Navigation (page 327) for more information on how these component tags use method expressions.

> In addition to using expressions with the standard component tags, you can also configure your custom component properties to accept expressions by creating `ValueExpression` or `MethodExpression` instances for them. See Creating Custom Component Classes (page 427) and Enabling Component Properties to Accept Expressions (page 433) for more information on enabling your component's attributes to support expressions.

> To learn more about using expressions to bind to backing bean properties, see Binding Component Values and Instances to External Data Sources (page 361).

> For information on referencing backing bean methods from component tags, see Referencing a Backing Bean Method (page 369).