Download PDF Home History |  | API Search Feedback FAQ

> ## 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}">
>       ...
>     </c:if>

> The JSP expression evaluator is responsible for handling EL expressions, which are enclosed by the `${ }` characters and can include literals. Here's an example:

>     <c:if test="${bean1.a < 3}" >
>       ...
>     </c:if>

> 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:

>     <c:if test="true" >
>     ...
>     </c:if>

> Literal values that contain the `${` characters must be escaped as follows:

>     <mytags:example attr1="an expression is ${'${'}true}" />

> ### Deactivating Expression Evaluation

> Because the pattern that identifies EL 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:

>     <%@ page isELIgnored ="true|false" %>

> 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 (see Deactivating EL Expression Evaluation`)`.

> ### Using Expressions

> EL expressions can be used:

> - In static text
> - In any standard or custom tag attribute that can accept an expression

> 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` (see body-content Attribute).

> There are three ways to set a tag attribute value:

> - With a single expression construct:

> `<some:tag value="${expr}"/>`

> The expression is evaluated and the result is coerced to the attribute's expected type.

> - With one or more expressions separated or surrounded by text:

> `<some:tag value="some${expr}${expr}text${expr}"/>`

> 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.

> - With text only:

> `<some:tag value="sometext"/>`

> In this case, the attribute's `String` value is 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 + 1.4}` provided as the value of an attribute of type `float` will result in the following conversion:

>     Float.valueOf("1.2E4 + 1.4").floatValue()

> See section JSP2.8 of the JSP 2.0 specification for the complete type conversion rules.

> ### Variables

> 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.

> Properties of variables are accessed using the `.` operator and can be nested arbitrarily.

> The JSP expression language unifies the treatment of the `.` and `[]` operators. `expr-a.expr-b` is equivalent to `a["expr-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.

> ### Implicit Objects

> The JSP expression language defines a set of implicit objects:

> - `pageContext`: The context for the JSP page. Provides access to various objects including:
> - `servletContext`: The context for the JSP page's servlet and any Web components contained in the same application. See Accessing the Web Context.
> - `session`: The session object for the client. See Maintaining Client State.
> - `request`: The request triggering the execution of the JSP page. See Getting Information from Requests.
> - `response`: The response returned by the JSP page. See Constructing Responses.

> In addition, several implicit objects are available that allow easy access to the following objects:

> - `param`: Maps a request parameter name to a single value
> - `paramValues`: Maps a request parameter name to an array of values
> - `header`: Maps a request header name to a single value
> - `headerValues`: Maps a request header name to an array of values
> - `cookie`: Maps a cookie name to a single cookie
> - `initParam`: Maps a context initialization parameter name to a single value

> Finally, there are objects that allow access to the various scoped variables described in Using Scope Objects.

> - `pageScope`: Maps page-scoped variable names to their values
> - `requestScope`: Maps request-scoped variable names to their values
> - `sessionScope`: Maps session-scoped variable names to their values
> - `applicationScope`: Maps application-scoped variable names to their values

> 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.

> ### Literals

> The JSP expression language defines the following literals:

> - Boolean: `true` and `false`
> - Integer: as in Java
> - Floating point: as in Java
> - String: with single and double quotes; `"` is escaped as `\"`, '`` is escaped as `\`', and `\` is escaped as `\\`.
> - Null: `null`

> ### Operators

> In addition to the `.` and `[]` operators discussed in Variables, the JSP expression language provides the following operators:

> - Arithmetic: `+`, `-` (binary), `*`, `/` and `div`, `%` and `mod`, `-` (unary)
> - Logical: `and`, `&&`, `or`, `||`, `not`, `!`
> - 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.
> - Conditional: `A ? B : C`. Evaluate `B` or `C`, depending on the result of the evaluation of `A`.

> The precedence of operators highest to lowest, left to right is as follows:

> - `[] .`
> - `()` - Used to change the precedence of operators.
> - `-` (unary)`not ! empty`
> - `* / div % mod`
> - `+ -` (binary)
> - `< > <= >= lt gt le ge`
> - `== != eq ne`
> - `&& and`
> - `|| or`
> - `? :`

> ### Reserved Words

> 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
>     not   lt   ge   null   div   mod

> 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.

> ### Examples

> Table 12-2 contains example EL expressions and the result of evaluating them.

> Table 12-2 Example Expressions
> EL Expression | Result
> --- | ---
> `${1 > (4/2)}` | `false`
> `${4.0 >= 3}` | `true`
> `${100.0 == 100}` | `true`
> `${(10*10) ne 100}` | `false`
> `${`'`a`'`<` '`b`'`}` | `true`
> `${`'`hip`'`gt` '`hit`'`}` | `false`
> `${4 > 3}` | `true`
> `${1.2E4 + 1.4}` | `12001.4`
> `${3 div 4}` | `0.75`
> `${10 mod 4}` | `2`
> `${!empty param.Add}` | True if the request parameter named `Add` is null or an empty string
> `${pageContext.request.contextPath}` | The context path
> `${sessionScope.cart.numberOfItems}` | The value of the `numberOfItems` property of the session-scoped attribute named `cart`
> `${param[`'`mycom.productId`'`]}` | The value of the request parameter named `mycom.productId`
> `${header["host"]}` | The host
> `${departments[deptName]}` | The value of the entry named `deptName` in the `departments` map
> `${requestScope['javax.servlet. forward.servlet_path']}` | The value of the request-scoped attribute named `javax.servlet. forward.servlet_path`

> ### Functions

> 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 (See Using Custom Tags and Chapter 15).

> #### Using Functions

> Functions can appear in static text and tag attribute values.

> 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,
>             localeString)}" >

> #### Defining Functions

> 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 `String`s as follows:

>     package mypkg;
>     public class MyLocales {

>       ...
>       public static boolean equals( String l1, String l2 ) {
>         return l1.equals(l2);
>       }
>     }

> Then you map the function name as used in the EL expression to the defining class and function signature in a TLD. The following `functions.tld` file in the date example maps the `equals` function to the class containing the implementation of the function `equals` and the signature of the function:

>     <function>
>       <name>equals</name>
>       <function-class>mypkg.MyLocales</function-class>
>       <function-signature>boolean equals( java.lang.String,
>         java.lang.String )</function-signature>
>     </function>

> A tag library can have only one `function` element that has any given `name` element.

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.