Expression Language
A primary feature of JSP technology
version 2.0 is its support for an expression language (EL). An expression
language makes it possible to easily access application data stored in
JavaBeans components. For example, the JSP expression language allows a page
author to access a bean using simple syntax such as ${name} for a simple
variable or ${name.foo.bar} for a nested property.
The test attribute of the following
conditional tag is supplied with an EL expression that compares the number of
items in the session-scoped bean named cart with 0:
<c:if
test="${sessionScope.cart.numberOfItems > 0}">
...
The JSP expression evaluator is
responsible for handling EL expressions, which are enclosed by the ${ }
characters and can include literals. Here's an example:
Any value that does not begin with ${
is treated as a literal and is parsed to the expected type using the PropertyEditor
for the type:
Because the pattern that
identifies expressions was not reserved
in the JSP specifications before JSP 2.0, there may be applications where such
a pattern is intended to pass through verbatim. To prevent the pattern from
being evaluated, you can deactivate EL evaluation.
To deactivate the evaluation of EL
expressions, you specify the isELIgnored attribute of the page directive:
The
valid values of this attribute are true and false. If it is true, EL
expressions are ignored when they appear in static text or tag attributes. If
it is false, EL expressions are evaluated by the container.
The default value varies depending
on the version of the web application deployment descriptor. The default mode
for JSP pages delivered using a Servlet 2.3 or earlier descriptor is to ignore
EL expressions; this provides backward compatibility. The default mode for JSP
pages delivered with a Servlet 2.4 descriptor is to evaluate EL expressions;
this automatically provides the default that most applications want. You can
also deactivate EL expression evaluation for a group of JSP pages.
The value of an expression in static
text is computed and inserted into the current output. If the static text
appears in a tag body, note that an expression will not be evaluated if
the body is declared to be tagdependent.
The expressions are evaluated from
left to right. Each expression is coerced to a String and then concatenated
with any intervening text. The resulting String is then coerced to the
attribute's expected type.
Expressions used to set attribute
values are evaluated in the context of an expected type. If the result of the
expression evaluation does not match the expected type exactly, a type
conversion will be performed. For example, the expression ${1.2E4} provided as
the value of an attribute of type float will result in the following
conversion:
The web container evaluates a
variable that appears in an expression by looking up its value according to the
behavior of PageContext.findAttribute(String). For example, when evaluating the
expression ${product}, the container will look for product in the page,
request, session, and application scopes and will return its value. If product
is not found, null is returned. A variable that matches one of the implicit
objects described in Implicit Objects will return that implicit
object instead of the variable's value.
The JSP expression language unifies
the treatment of the . and [] operators. expr-a.identifier-b is equivalent to
expr-a["identifier-b"]; that is, the expression expr-b is used to
construct a literal whose value is the identifier, and then the [] operator is
used with that value.
To evaluate expr-a[expr-b], evaluate
expr-a into value-a and evaluate expr-b into value-b. If either value-a or value-b
is null, return null.
·
If
value-a is a Map, return value-a.get(value-b). If !value-a.containsKey(value-b),
then return null.
·
If
value-a is a List or array, coerce value-b to int and return value-a.get(value-b)
or Array.get(value-a, value-b), as appropriate. If the coercion couldn't be
performed, an error is returned. If the get call returns an IndexOutOfBoundsException,
null is returned. If the get call returns another exception, an error is
returned.
·
If
value-a is a JavaBeans object, coerce value-b to String. If value-b is a
readable property of value-a, then return the result of a get call. If the get
method throws an exception, an error is returned.
o servletContext: The context for the
JSP page's servlet and any web components contained in the same application.
See Accessing the Web Context.
o request: The request triggering the
execution of the JSP page. See Getting Information from Requests.
In addition, several implicit
objects are available that allow easy access to the following objects:
Finally, there are objects that
allow access to the various scoped variables described in Using Scope Objects.
When an expression references one of
these objects by name, the appropriate object is returned instead of the
corresponding attribute. For example, ${pageContext} returns the PageContext
object, even if there is an existing pageContext attribute containing some other
value.
·
String:
with single and double quotes; " is escaped as \", ' is escaped as \',
and \ is escaped as \\.
In addition to the . and []
operators discussed in Variables, the JSP expression language
provides the following operators:
·
Relational:
==, eq, !=, ne, <, lt, >, gt, <=, ge, >=, le. Comparisons can be
made against other values, or against boolean, string, integer, or floating
point literals.
·
Empty:
The empty operator is a prefix operation that can be used to determine whether
a value is null or empty.
The following words are reserved for
the JSP expression language and should not be used as identifiers.
and eq gt true instanceof
or ne le false empty
Note that many of these words are
not in the language now, but they may be in the future, so you should avoid
using them.
contains example EL expressions and
the result of evaluating them.
The JSP expression language allows
you to define a function that can be invoked in an expression. Functions are
defined using the same mechanisms as custom tags
To use a function in a JSP page, you
use a taglib directive to import the tag library containing the function. Then
you preface the function invocation with the prefix declared in the directive.
For example, the date example page index.jsp
imports the /functions library and invokes the function equals in an
expression:
<%@ taglib prefix="f"
uri="/functions"%>
...
<c:when
test="${f:equals(selectedLocaleString,
To define a function you program it
as a public static method in a public class. The mypkg.MyLocales class in the date
example defines a function that tests the equality of two Strings as follows:
package mypkg;
public class MyLocales
public static boolean
equals
Tidak ada komentar:
Posting Komentar