Binding Component Values and Instances to External Data Sources






Binding Component Values and Instances to External Data Sources

As explained in Backing Beans (page 304), 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 expression to bind the component's value to an external data source, such as a bean property. A component tag's binding attribute uses a value expression to bind a component instance to a bean property.

When a component instance is bound to a backing bean property, the property holds the component's local value. Conversely, when a component's value is bound to a backing bean property, the property holds the value stored in the backing bean. This value is updated with the local value during the update model values phase of the life cycle. There are advantages to both of these techniques.

Binding a component instance to a bean property has these advantages:

  • The backing bean can programmatically modify component attributes.

  • The backing bean can instantiate components rather than let the page author do so.

Binding a component's value to a bean property has these advantages:

  • The page author has more control over the component attributes.

  • The backing bean has no dependencies on the JavaServer Faces API (such as the UI component classes), allowing for greater separation of the presentation layer from the model layer.

  • The JavaServer Faces implementation can perform conversions on the data based on the type of the bean property without the developer needing to apply a converter.

In most situations, you will bind a component's value rather than its instance to a bean property. You'll need to use a component binding only when you need to change one of the component's attributes dynamically. For example, if an application renders a component only under certain conditions, it can set the component's rendered property accordingly by accessing the property to which the component is bound.

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. Figure lists some example value-binding expressions that you can use with the value attribute.

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 Beans (page 304), the value 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 expression must match the managed-bean-name element of the managed bean declaration up to the first period (.) in the expression. Similarly, the part of the value expression after the period 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 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 period must match the property name as it is defined in the backing bean.

See Application Configuration Resource File (page 458) for information on how to configure beans in the application configuration resource file.

Writing Bean Properties (page 390) 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 (page 409) for more information on how this listener works. See Registering a Value-Change Listener on a Component (page 366) 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. Figure 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.

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 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 (page 399) 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.



 Python   SQL   Java   php   Perl 
 game development   web development   internet   *nix   graphics   hardware 
 telecommunications   C++ 
 Flash   Active Directory   Windows