JSP 2.0: The New Deal, Part 1

The wait is almost over: the latest version of the
JavaServer Pages
(JSP) specification, JSP 2.0, is about to be released, along with all of
the other J2EE 1.4 specifications. The jump to a new major revision
for this JSP version signifies that all of the pieces are now in place
for using JSP in a new way: there's no need for Java in the pages, thanks to
the new Expression Language (EL) and the JSP Standard Tag Library (JSTL),
and reusing code is much easier, thanks
to two new ways to develop custom actions.
More specifically, JSP 2.0 brings you all of these goodies:

The Expression Language first introduced by the JSTL 1.0
specification is now incorporated in the JSP specification, making
it available for use with all standard and custom components, as
well as in template text.

The EL has been extended with a function call mechanism that
JSTL 1.1 takes advantage of to make a set of commonly needed
functions readily available.

JSP error pages now have access to more information about the
error, through new variables that are better aligned with the
error-handling mechanism defined by the servlet specification.

The requirements for how containers report JSP syntax errors have
been made stricter to make it easier to find out what's wrong.

All J2EE 1.4 specifications, including JSP 2.0 and Servlet 2.4,
use XML schema for declaration of the deployment descriptor rules.
One benefit of this is that you can now list the declarations in
the web.xml file in any order. JSP 2.0 also adds a number
of new configuration options to the deployment descriptor, to
allow for global configuration instead of per-page configuration.

Writing JSP pages as XML documents is now much easier, thanks to
more flexible rules and new standard action elements.

Custom tag libraries can now be developed as a set of tag
files (text files with JSP elements), and tag handlers
implemented as Java classes can use a new, simplified tag handler
API. At the same time, a number of new features, such as support
for a dynamic attribute list and executable fragment attributes,
have been added.

This article is the first in a series of articles describing
all of these new JSP 2.0 features. In this part, we'll look at the
EL-related news, saving the other features for future installments.
I have assumed that you're familiar with JSP 1.2 and have at
least heard about the JSP Standard Tag Library (JSTL).

You may also be interested in the third edition of my
JavaServer
Pages book, where I describe all of this in much more detail
and don't assume that you know anything about JSP or JSTL. The book is
scheduled for release in December 2003, but you can pre-order it now at
Amazon.com, Barnes & Noble, and other online and brick-and-mortar
bookstores.

The Expression Language

If you've used JSTL, you're already familiar with the JSP Expression
Language. The EL was introduced in the JSTL 1.0 specification
to provide an alternative to Java expressions for assigning values to
action element attributes at runtime. While the JSTL EL has quickly
become very popular, there's a problem: JSTL EL expressions only works
with JSTL actions and with custom actions specifically crafted to know
how to evaluate EL expressions using non-standard APIs.

Starting with JSP 2.0, the JSP container itself understands EL
expressions, making it possible to use them in all places where
you previously could only use Java expressions: as the value of
attributes for standard and custom actions, and directly
in template text.

Before we look at concrete examples, let's take a closer look at what
the EL is. The EL is a language inspired by JavaScript, and to
some extent, XPath (a language used to access pieces of an XML document),
but the EL is much more forgiving about variables without a value
(null) and performs more data-type conversions
automatically. These features are important for a web application, where
the input is mostly in the form of request parameters. The parameters
may be present in some requests but not in others, and the browser
always sends request parameters as text values, while the application
often needs to use them as numbers or Boolean values (true
or false). The way the EL is designed, you rarely need to
worry about absent values or type conversion at all.

An EL expression contains variables and operators. Any bean stored in
one of the JSP scopes (page, request, session, or application) can be
used as an EL variable. In addition, the EL supports the following
implicit (predefined) variables:

Variable name

Description

pageScope

A collection (a java.util.Map) of all page scope
variables.

requestScope

A collection (a java.util.Map) of all request scope
variables.

sessionScope

A collection (a java.util.Map) of all session scope
variables.

applicationScope

A collection (a java.util.Map) of all application
scope variables.

param

A collection (a java.util.Map) of all request
parameter values as a single String value per
parameter.

paramValues

A collection (a java.util.Map) of all request
parameter values as a String array per parameter.

header

A collection (a java.util.Map) of all request header
values as a single String value per header.

headerValues

A collection (a java.util.Map) of all request header
values as a String array per header.

cookie

A collection (a java.util.Map) of all request cookie
values as a single javax.servlet.http.Cookie value
per cookie.

initParam

A collection (a java.util.Map) of all application
initialization parameter values as a single String
value per parameter.

pageContext

An instance of the javax.servlet.jsp.PageContext
class, providing access to various request data.

Operators describe what you want to do with the variables. The operators
you can use in an EL expression probably look familiar to you if
you've used any programming language before, because they are the same
as those supported by most languages:

Operator

Description

.

Access a bean property or Map entry.

[]

Access an array or List element.

()

Group a subexpression to change the evaluation order.

? :

Conditional test: condition ? ifTrue : ifFalse.

+

Addition.

-

Subtraction or negation of a value.

*

Multiplication.

/ or div

Division.

% or mod

Modulo (remainder).

== or eq

Test for equality.

!= or ne

Test for inequality.

< or lt

Test for less than.

> or gt

Test for greater than.

<= or le

Test for less than or equal.

>= or ge

Test for greater than or equal.

&& or and

Test for logical AND.

|| or or

Test for logical OR.

! or not

Unary Boolean complement.

empty

Test for an empty variable value: null, an empty
String, or an array, Map, or
Collection without entries).

func(args)

A function call, where func is the
function name and args is zero, one or more
comma-separated function arguments.

An EL expression can also include literals: numbers,
text (within single or double quotes), Boolean values and
null.

Because an EL expression can appear in many places where
static text can also appear, you must tell the JSP container that it
should treat an EL expression as such. You do this using delimiters. An
EL expression always starts with the ${ delimiter (a
dollar sign and a left curly brace) and ends with }
(a right curly brace). Here's an EL expression that adds 5 to a variable
named amount:

${amount + 5}

If you want to add 5 to the value of a bean property, you use the
property access operator:

${order.amount + 5}

The property accessor operator (the dot) tells the EL to look for
the named property (amount, in this case) in the specified
bean or collection (order, in this case, which can be
either a bean or a java.util.Map).

As an alternative, you can use the array element access operator:

${order['amount'] + 5}

The value within the brackets must be either a string literal for the
name of the property (as in this example) or a variable (or even a
complete EL subexpression) that holds the name of the property.

EL expressions can be used to assign values to any standard or custom
JSP action attributes marked as accepting a dynamic value
(or request-time attribute value, as it's formally called):

<c:out value="${order.amount + 5}"/>

Prior to JSP 2.0, you had to use a Java expression to assign a
dynamic value to an attribute, which has been a common source of
confusing syntax errors over the years.

Finally, EL expressions can be mixed with template text directly in
the page. This comes in very handy when you're generating HTML
elements and need to set an attribute to a dynamic value:

<input name="firstName" value="${customer.firstName}">

With JSP 1.2, you had to use JSTL's <c:out>
action to accomplish the same thing, ending up with a mix of elements of
different types that was hard to understand: