Download PDF Home History |  | API Search Feedback FAQ

> ## Binding Component Values and Instances to External Data Sources

> As explained in Backing Bean Management, a component tag can wire its component's data to a back-end data object by doing one of the following:

> - Binding its component's value to a bean property or other external data source
> - Binding its component's instance to a bean property

> A component tag's `value` attribute uses a value-binding expression to bind a component's value to an external data source, such as a bean property. A component tag's `binding` attribute uses a value-binding expression to bind a component instance to a bean property.

> When referencing the property using the component tag's `value` attribute, you need to use the proper syntax. For example, suppose a backing bean called `MyBean` has this `int` property:

>     int currentOption = null;
>     int getCurrentOption(){...}
>     void setCurrentOption(int option){...}

> The value attribute that references this property must have this value-binding expression:

>     #{MyBean.currentOption}

> In addition to binding a component's value to a bean property, the `value` attribute can specify a literal value or can map the component's data to any primitive (such as `int`), structure (such as an array), or collection (such as a list), independent of a JavaBeans component. Table 18-8 lists some example value-binding expressions that you can use with the `value` attribute.

> Table 18-8 Example Value-binding Expressions
> Value | Expression
> --- | ---
> A Boolean | `cart.numberOfItems > 0`
> A property initialized from a context `init` parameter | `initParam.quantity`
> A bean property | `CashierBean.name`
> Value in an array | `books[3]`
> Value in a collection | `books["fiction"]`
> Property of an object in an array of objects | `books[3].price`

> The next two sections explain in more detail how to use the `value` attribute to bind a component's value to a bean property or other external data sources and how to use the `binding` attribute to bind a component instance to a bean property

> ### Binding a Component Value to a Property

> To bind a component's value to a bean property, you specify the name of the bean and the property using the `value` attribute. As explained in Backing Bean Management, the value-binding expression of the component tag's `value` attribute must match the corresponding managed bean declaration in the application configuration resource file.

> This means that the name of the bean in the value-binding expression must match the `managed-bean-name` element of the managed bean declaration up to the first . in the expression. Similarly, the part of the value-binding expression after the . must match the name specified in the corresponding `property-name` element in the application configuration resource file.

> For example, consider this managed bean configuration, which configures the `ImageArea` bean corresponding to the North America part of the image map on the `chooselocale.jsp` page of the Duke's Bookstore application:

>     <managed-bean>
>       <managed-bean-name> NA </managed-bean-name>
>       <managed-bean-class> model.ImageArea </managed-bean-class>
>       <managed-bean-scope> application </managed-bean-scope>
>       <managed-property>
>         <property-name>shape</property-name>
>         <value>poly</value>
>       </managed-property>
>       <managed-property>
>         <property-name>alt</property-name>
>         <value>NAmerica</value>
>       </managed-property>
>       ...
>     </managed-bean>

> This example configures a bean called `NA`, which has several properties, one of which is called `shape`.

> Although the `area` tags on the `chooselocale.jsp` page do not bind to an `ImageArea` property (they bind to the bean itself), to do this, you refer to the property using a value-binding expression from the `value` attribute of the component's tag:

>     <h:outputText value="#{NA.shape}" />

> Much of the time you will not include definitions for a managed bean's properties when configuring it. You need to define a property and its value only when you want the property to be initialized with a value when the bean is initialized.

> If a component tag's `value` attribute must refer to a property that is not initialized in the `managed-bean` configuration, the part of the value-binding expression after the . must match the property name as it is defined in the backing bean.

> See Application Configuration Resource File for information on how to configure beans in the application configuration resource file.

> Writing Component Properties explains in more detail how to write the backing bean properties for each of the component types.

> ### Binding a Component Value to an Implicit Object

> One external data source that a `value` attribute can refer to is an implicit object.

> The `bookreceipt.jsp` page of the Duke's Bookstore application includes a reference to an implicit object from a parameter substitution tag:

>     <h:outputFormat title="thanks"
>     value="#{bundle.ThankYouParam}">
>       <f:param value="#{sessionScope.name}"/>
>     </h:outputFormat>

> This tag gets the name of the customer from the session scope and inserts it into the parameterized message at the key `ThankYouParam` from the resource bundle. For example, if the name of the customer is Gwen Canigetit, this tag will render:

>     Thank you, Gwen Canigetit, for purchasing your books from us.

> The `name` tag on the `bookcashier.jsp` page has the `NameChanged` listener implementation registered on it. This listener saves the customer's name in the session scope when the `bookcashier.jsp` page is submitted. See Implementing Value-Change Listeners for more information on how this listener works. See Registering a Value-Change Listener on a Component to learn how the listener is registered on the tag.

> Retrieving values from other implicit objects is done in a similar way to the example shown in this section. Table 18-9 lists the implicit objects that a value attribute can refer to. All of the implicit objects except for the scope objects are read-only and therefore should not be used as a value for a `UIInput` component.

> Table 18-9 Implicit Objects
> Implicit Object | What It Is
> --- | ---
> `applicationScope` | A `Map` of the application scope attribute values, keyed by attribute name
> `cookie` | A `Map` of the cookie values for the current request, keyed by cookie name
> `facesContext` | The `FacesContext` instance for the current request
> `header` | A `Map` of HTTP header values for the current request, keyed by header name
> `headerValues` | A `Map` of `String` arrays containing all the header values for HTTP headers in the current request, keyed by header name
> `initParam` | A `Map` of the context initialization parameters for this Web application
> `param` | A `Map` of the request parameters for this request, keyed by parameter name
> `paramValues` | A `Map` of `String` arrays containing all the parameter values for request parameters in the current request, keyed by parameter name
> `requestScope` | A `Map` of the request attributes for this request, keyed by attribute name
> `sessionScope` | A `Map` of the session attributes for this request, keyed by attribute name
> `view` | The root `UIComponent` in the current component tree stored in the `FacesRequest` for this request

> ### Binding a Component Instance to a Bean Property

> A component instance can be bound to a bean property using a value-binding expression with the `binding` attribute of the component's tag. You usually bind a component instance rather than its value to a bean property if the bean must dynamically change the component's attributes.

> Here are two tags from the `bookcashier.jsp` page that bind components to bean properties:

>     <h:selectBooleanCheckbox
>       id="fanClub"
>       rendered="false"
>       binding="#{cashier.specialOffer}" />
>     <h:outputLabel for="fanClub"
>       rendered="false"
>       binding="#{cashier.specialOfferText}"  >
>       <h:outputText id="fanClubLabel"
>         value="#{bundle.DukeFanClub}"
>       />
>     </h:outputLabel>

> The `selectBooleanCheckbox` tag renders a checkbox and binds the `fanClub` `UISelectBoolean` component to the `specialOffer` property of `CashierBean`. The `outputLabel` tag binds the component representing the checkbox's label to the `specialOfferText` property of `CashierBean`. If the application's locale is English, the `outputLabel` tag renders:

>     I'd like to join the Duke Fan Club, free with my purchase of
>     over $100

> The `rendered` attributes of both tags are set to `false`, which prevents the checkbox and its label from being rendered. If the customer orders more than $100 (or 100 euros) worth of books and clicks the `Submit` button, the `submit` method of `CashierBean` sets both components' `rendered` properties to `true`, causing the checkbox and its label to be rendered.

> These tags use component bindings rather than value bindings because the backing bean must dynamically set the values of the components' `rendered` properties.

> If the tags were to use value bindings instead of component bindings, the backing bean would not have direct access to the components, and would therefore require additional code to access the components from the `FacesContext` instance to change the components' `rendered` properties.

> Writing Properties Bound to Component Instances explains how to write the bean properties bound to the example components and also discusses how the `submit` method sets the `rendered` properties of the components.

Download PDF Home History |  | API Search Feedback FAQ

All of the material in The J2EE(TM) 1.4 Tutorial is copyright-protected and may not be published in other works without express written permission from Sun Microsystems.