type=page
status=published
title=Immediate and Deferred Evaluation Syntax
next=jsf-el003.html
prev=jsf-el001.html
~~~~~~
Immediate and Deferred Evaluation Syntax
========================================

[[BNAHR]]

[[immediate-and-deferred-evaluation-syntax]]
Immediate and Deferred Evaluation Syntax
----------------------------------------

The EL supports both immediate and deferred evaluation of expressions.
Immediate evaluation means that the expression is evaluated and the
result returned as soon as the page is first rendered. Deferred
evaluation means that the technology using the expression language can
use its own machinery to evaluate the expression sometime later during
the page's lifecycle, whenever it is appropriate to do so.

Those expressions that are evaluated immediately use the `${}` syntax.
Expressions whose evaluation is deferred use the `#{}` syntax.

Because of its multiphase lifecycle, JavaServer Faces technology uses
mostly deferred evaluation expressions. During the lifecycle, component
events are handled, data is validated, and other tasks are performed in
a particular order. Therefore, a JavaServer Faces implementation must
defer evaluation of expressions until the appropriate point in the
lifecycle.

Other technologies using the EL might have different reasons for using
deferred expressions.

[[BNAHS]]

[[immediate-evaluation]]
Immediate Evaluation
~~~~~~~~~~~~~~~~~~~~

All expressions using the `${}` syntax are evaluated immediately. These
expressions can appear as part of a template (static) text or as the
value of a tag attribute that can accept runtime expressions.

The following example shows a tag whose `value` attribute references an
immediate evaluation expression that updates the quantity of books
retrieved from the backing bean named `catalog`:

[source,oac_no_warn]
----
<h:outputText value="${catalog.bookQuantity}" />
----

The JavaServer Faces implementation evaluates the expression
`${catalog.bookQuantity}`, converts it, and passes the returned value to
the tag handler. The value is updated on the page.

[[BNAHT]]

[[deferred-evaluation]]
Deferred Evaluation
~~~~~~~~~~~~~~~~~~~

Deferred evaluation expressions take the form `#{expr}` and can be
evaluated at other phases of a page lifecycle as defined by whatever
technology is using the expression. In the case of JavaServer Faces
technology, its controller can evaluate the expression at different
phases of the lifecycle, depending on how the expression is being used
in the page.

The following example shows a JavaServer Faces `h:inputText` tag, which
represents a field component into which a user enters a value. The
`h:inputText` tag's `value` attribute references a deferred evaluation
expression that points to the `name` property of the `customer` bean:

[source,oac_no_warn]
----
<h:inputText id="name" value="#{customer.name}" />
----

For an initial request of the page containing this tag, the JavaServer
Faces implementation evaluates the `#{customer.name}` expression during
the render-response phase of the lifecycle. During this phase, the
expression merely accesses the value of `name` from the `customer` bean,
as is done in immediate evaluation.

For a postback request, the JavaServer Faces implementation evaluates
the expression at different phases of the lifecycle, during which the
value is retrieved from the request, validated, and propagated to the
`customer` bean.

As shown in this example, deferred evaluation expressions can be

* Value expressions that can be used to both read and write data
* Method expressions

Value expressions (both immediate and deferred) and method expressions
are explained in the next section.


