jsp c:if

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} provided as the value
of an attribute of type float will result in the following conversion:

Float.valueOf("1.2E4").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.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.
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 Strings 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.