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

> ## Configuring Navigation Rules

> As explained in Navigation Model (page 292), navigation is a set of rules for choosing the next page to be displayed after a button or hyperlink component is clicked. Navigation rules are defined in the application configuration resource file.

> Each navigation rule specifies how to navigate from one page to a set of other pages. The JavaServer Faces implementation chooses the proper navigation rule according to which page is currently displayed.

> After the proper navigation rule is selected, the choice of which page to access next from the current page depends on the action method that was invoked when the component was clicked and the logical outcome that is referenced by the component's tag or was returned from the action method.

> The outcome can be anything the developer chooses, but Table 13-3 lists some outcomes commonly used in web applications.

> Table 13-3 Common Outcome Strings
> Outcome | What It Means
> --- | ---
> `success` | Everything worked. Go on to the next page.
> `failure` | Something is wrong. Go on to an error page.
> `logon` | The user needs to log on first. Go on to the logon page.
> `no results` | The search did not find anything. Go to the search page again.

> Usually, the action method performs some processing on the form data of the current page. For example, the method might check whether the user name and password entered in the form match the user name and password on file. If they match, the method returns the outcome `success`. Otherwise, it returns the outcome `failure`. As this example demonstrates, both the method used to process the action and the outcome returned are necessary to determine the proper page to access.

> Here is a navigation rule that could be used with the example just described:

>     <navigation-rule>
>       <from-view-id>/logon.jsp</from-view-id>
>       <navigation-case>
>         <from-action>#{LogonForm.logon}</from-action>
>         <from-outcome>success</from-outcome>
>         <to-view-id>/storefront.jsp</to-view-id>
>       </navigation-case>
>       <navigation-case>
>         <from-action>#{LogonForm.logon}</from-action>
>         <from-outcome>failure</from-outcome>
>         <to-view-id>/logon.jsp</to-view-id>
>         </navigation-case>
>     </navigation-rule>

> This navigation rule defines the possible ways to navigate from `logon.jsp`. Each `navigation-case` element defines one possible navigation path from `logon.jsp`. The first `navigation-case` says that if `LogonForm.logon` returns an outcome of `success`, then `storefront.jsp` will be accessed. The second `navigation-case` says that `logon.jsp` will be rerendered if `LogonForm.logon` returns `failure`.

> An application's navigation configuration consists of a set of navigation rules. Each rule is defined by the `navigation-rule` element in the `faces-config.xml` file.

> The navigation rules of the Duke's Bookstore application are very simple. Here are two complex navigation rules that could be used with the Duke's Bookstore application:

>     <navigation-rule>
>       <from-view-id>/catalog.jsp</from-view-id>
>       <navigation-case>
>         <from-outcome>success</from-outcome>
>         <to-view-id>/bookcashier.jsp</to-view-id>
>       </navigation-case>
>       <navigation-case>
>         <from-outcome>out of stock</from-outcome>
>         <from-action>
>           #{catalog.buy}
>         </from-action>
>         <to-view-id>/outofstock.jsp</to-view-id>
>       </navigation-case>
>       <navigation-case>
>         <from-outcome>error</from-outcome>
>         <to-view-id>/error.jsp</to-view-id>
>       </navigation-case>
>     </navigation-rule>

> The first navigation rule in this example says that the application will navigate from `catalog.jsp` to

> - `bookcashier.jsp` if the item ordered is in stock
> - `outofstock.jsp` if the item is out of stock

> The second navigation rule says that the application will navigate from any page to `error.jsp` if the application encountered an error.

> Each `navigation-rule` element corresponds to one component tree identifier defined by the optional `from-view-id` element. This means that each rule defines all the possible ways to navigate from one particular page in the application. If there is no `from-view-id` element, the navigation rules defined in the `navigation-rule` element apply to all the pages in the application. The `from-view-id` element also allows wildcard matching patterns. For example, this `from-view-id` element says that the navigation rule applies to all the pages in the `books` directory:

>     <from-view-id>/books/*</from-view-id>

> As shown in the example navigation rule, a `navigation-rule` element can contain zero or more `navigation-case` elements. The `navigation-case` element defines a set of matching criteria. When these criteria are satisfied, the application will navigate to the page defined by the `to-view-id` element contained in the same `navigation-case` element.

> The navigation criteria are defined by optional `from-outcome` and `from-action` elements. The `from-outcome` element defines a logical outcome, such as `success`. The `from-action` element uses a method expression to refer to an action method that returns a `String`, which is the logical outcome. The method performs some logic to determine the outcome and returns the outcome.

> The `navigation-case` elements are checked against the outcome and the method expression in this order:

> - Cases specifying both a `from-outcome` value and a `from-action` value. Both of these elements can be used if the action method returns different outcomes depending on the result of the processing it performs.
> - Cases specifying only a `from-outcome` value. The `from-outcome` element must match either the outcome defined by the `action` attribute of the `UICommand` component or the outcome returned by the method referred to by the `UICommand` component.
> - Cases specifying only a `from-action` value. This value must match the `action` expression specified by the component tag.

> When any of these cases is matched, the component tree defined by the `to-view-id` element will be selected for rendering.

> Referencing a Method That Performs Navigation (page 370) explains how to use a component tag's `action` attribute to point to an action method. Writing a Method to Handle Navigation (page 409) explains how to write an action method.