Download PDF Home History |  | API Search Feedback FAQ

> ## Referencing a Backing Bean Method

> A component tag has a set of attributes for referencing backing bean methods that can perform certain functions for the component associated with the tag. These attributes are summarized in Table 18-10.

> Table 18-10 Component Tag Attributes that Reference Backing Bean Methods
> Attribute | Function
> --- | ---
> `action` | Refers to a backing bean method that performs navigation processing for the component and returns a logical outcome `String`
> `actionListener` | Refers to a backing bean method that handles action events
> `validator` | Refers to a backing bean method that performs validation on the component's value
> `valueChangeListener` | Refers to a backing bean method that handles value-change events

> Only components that implement `ActionSource` can use the `action` and `actionListener` attributes. Only `UIInput` components or components that extend `UIInput` can use the `validator` or `valueChangeListener` attributes.

> The component tag refers to a backing bean method using a method-binding expression as a value of one of the attributes. The following four sections give examples of how to use the four different attributes.

> ### Referencing a Method That Performs Navigation

> If your page includes a component (such as a button or hyperlink) that causes the application to navigate to another page when the component is activated, the tag corresponding to this component must include an `action` attribute. This attribute does one of the following

> - Specifies a logical outcome `String` that tells the application which page to access next
> - References a backing bean method that performs some processing and returns a logical outcome `String`

> The `bookcashier.jsp` page of the Duke's Bookstore application has a `commandButton` tag that refers to a backing bean method that calculates the shipping date. If the customer has ordered more than $100 (or 100 euros) worth of books, this method also sets the `rendered` properties of some of the components to `true` and returns `null`; otherwise it returns `receipt`, which causes the `bookreceipt.jsp` page to display. Here is the `commandButton` tag from the `bookcashier.jsp` page:

>     <h:commandButton
>       value="#{bundle.Submit}"
>       action="#{cashier.submit}" />

> The `action` attribute uses a method-binding expression to refer to the `submit` method of `CashierBean`. This method will process the event fired by the component corresponding to this tag.

> Writing a Method to Handle Navigation describes how to implement the `submit` method of `CashierBean`.

> The application architect must configure a navigation rule that determines which page to access given the current page and the logical outcome, which is either returned from the backing bean method or specified in the tag. See Configuring Navigation Rules for information on how to define navigation rules in the application configuration resource file.

> ### Referencing a Method That Handles an Action Event

> If a component on your page generates an action event, and if that event is handled by a backing bean method, you refer to the method by using the component's `actionListener` attribute.

> The `chooselocale.jsp` page of the Duke's Bookstore application includes some components that generate action events. One of them is the `NAmerica` component:

>     <h:commandLink id="NAmerica" action="bookstore"
>       actionListener="#{localeBean.chooseLocaleFromLink}">

> The `actionListener` attribute of this component tag references the `chooseLocaleFromLink` method using a method-binding expression. The `chooseLocaleFromLink` method handles the event of a user clicking on the hyperlink rendered by this component.

> The `actionListener` attribute can be used only with the tags of components that implement `ActionSource`. These include `UICommand` components.

> Writing a Method to Handle an Action Event describes how to implement a method that handles an action event.

> ### Referencing a Method That Performs Validation

> If the input of one of the components on your page is validated by a backing bean method, you refer to the method from the component's tag using the `validator` attribute.

> The Coffee Break application includes a method that performs validation of the `email` input component on the `checkoutForm.jsp` page. Here is the tag corresponding to this component:

>     <h:inputText id="email" value="#{checkoutFormBean.email}"
>       size="25" maxlength="125"
>       validator="#{checkoutFormBean.validateEmail}"/>

> This tag references the `validate` method described in Writing a Method to Perform Validation using a method-binding expression.

> The `validator` attribute can be used only with `UIInput` components or those components whose classes extend `UIInput`.

> Writing a Method to Perform Validation describes how to implement a method that performs validation.

> ### Referencing a Method That Handles a Value-change Event

> If you want a component on your page to generate a value-change event and you want that event to be handled by a backing bean method, you refer to the method using the component's `valueChangeListener` attribute.

> The `name` component on the `bookcashier.jsp` page of the Duke's Bookstore application references a `ValueChangeListener` implementation that handles the event of a user entering a name in the `name` input field:

>     <h:inputText
>       id="name"
>       size="50"
>       value="#{cashier.name}"
>       required="true">
>       <f:valueChangeListener type="listeners.NameChanged" />
>     </h:inputText>

> For illustration, Writing a Method to Handle a Value-Change Event describes how to implement this listener with a backing bean method instead of a listener implementation class. To refer to this backing bean method, the tag uses the `valueChangeListener` attribute:

>     <h:inputText
>       id="name"
>       size="50"
>       value="#{cashier.name}"
>       required="true"
>       valueChangeListener="#{cashier.processValueChange}" />
>     </h:inputText>

> The `valueChangeListener` attribute of this component tag references the `processValueChange` method of `CashierBean` using a method-binding expression. The `processValueChange` method handles the event of a user entering his name in the input field rendered by this component.

> The `valueChangeListener` attribute can be used only with the tags of `UIInput` components and components whose classes extend `UIInput`.

> Writing a Method to Handle a Value-Change Event describes how to implement a method that handles a `ValueChangeEvent`.

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.