Web Programming with Servlets and JSP Knowledge Downloads

Core Tag Library

Table 14-3 summarizes the core tags, which include those related to variables and flow control, as well as a
generic way to access URL-based resources whose content can then be included or processed within the
JSP page.

Table 14-3 Core Tags

Area Function Tags Prefix
Variable support Remove
Set
Flow control choose
when
otherwise
forEach
forTokens
Core if c
URL management import
param
redirect
param
url
param
Miscellaneous catch
out

Variable Support Tags

The set tag sets the value of an EL variable or the property of an EL variable in any of the JSP scopes
(page, request, session, or application). If the variable does not already exist, it is created.

The JSP EL variable or property can be set either from the attribute value:

<c:set var="foo" scope="session" value="..."/>

or from the body of the tag:

<c:set var="foo">
...
</c:set>

For example, the following sets an EL variable named bookID with the value of the request parameter
named Remove:

<c:set var="bookId" value="${param.Remove}"/>

To remove an EL variable, you use the remove tag. When the bookstore JSP page bookreceipt.jsp
is invoked, the shopping session is finished, so the cart session attribute is removed as follows:

<c:remove var="cart" scope="session"/>

Flow Control Tags

To execute flow control logic, a page author must generally resort to using scriptlets. For example, the
following scriptlet is used to iterate through a shopping cart:

2007 Aptech Ltd Version 1.0 Page 1 of 5

Web Programming with Servlets and JSP Knowledge Downloads

<%
Iterator i = cart.getItems().iterator();
while (i.hasNext()) {
ShoppingCartItem item =
(ShoppingCartItem)i.next();
...
%>
<tr>
<td align="right" bgcolor="#ffffff">
${item.quantity}
</td>
...
<%
}
%>

Flow control tags eliminate the need for scriptlets. The next two sections have examples that demonstrate
the conditional and iterator tags.

Conditional Tags

The if tag allows the conditional execution of its body according to the value of the test attribute. The
following example from bookcatalog.jsp tests whether the request parameter Add is empty. If the test
evaluates to true, the page queries the database for the book record identified by the request parameter
and adds the book to the shopping cart:

<c:if test="${!empty param.Add}">

<c:set var="bid" value="${param.Add}"/>
<jsp:useBean id="bid" type="java.lang.String" />
<sql:query var="books"
dataSource="${applicationScope.bookDS}">
select * from PUBLIC.books where id = ?
<sql:param value="${bid}" />
</sql:query>
<c:forEach var="bookRow" begin="0" items="${books.rows}">
<jsp:useBean id="bookRow" type="java.util.Map" />
<jsp:useBean id="addedBook"
class="database.BookDetails" scope="page" />
...
<% cart.add(bid, addedBook); %>
...
</c:if>

The choose tag performs conditional block execution by the embedded when subtags. It renders the body
of the first when tag whose test condition evaluates to true. If none of the test conditions of nested when
tags evaluates to true, then the body of an otherwise tag is evaluated, if present.
For example, the following sample code shows how to render text based on a customer's membership
category.

<c:choose>
<c:when test="${customer.category == 'trial'}" >
...
</c:when>
<c:when test="${customer.category == 'member'}" >
...
</c:when>

2007 Aptech Ltd Version 1.0 Page 2 of 5

Web Programming with Servlets and JSP Knowledge Downloads

<c:when test="${customer.category == 'preferred'}" >

...
</c:when>
<c:otherwise>
...
</c:otherwise>
</c:choose>

The choose, when, and otherwise tags can be used to construct an if-then-else statement as
follows:

<c:choose>
<c:when test="${count == 0}" >
No records matched your selection.
</c:when>
<c:otherwise>
${count} records matched your selection.
</c:otherwise>
</c:choose>

Iterator Tags

The forEach tag allows you to iterate over a collection of objects. You specify the collection via the
items attribute, and the current item is available through a variable named by the var attribute.
A large number of collection types are supported by forEach, including all implementations of
java.util.Collection and java.util.Map. If the items attribute is of type
java.util.Map, then the current item will be of type java.util.Map.Entry, which has the
following properties:

key: The key under which the item is stored in the underlying Map
value: The value that corresponds to the key

Arrays of objects as well as arrays of primitive types (for example, int) are also supported. For arrays of
primitive types, the current item for the iteration is automatically wrapped with its standard wrapper class (for
example, Integer for int, Float for float, and so on).

Implementations of java.util.Iterator and java.util.Enumeration are supported, but they

must be used with caution. Iterator and Enumeration objects are not resettable, so they should not
be used within more than one iteration tag. Finally, java.lang.String objects can be iterated over if
the string contains a list of comma-separated values (for example:
Monday,Tuesday,Wednesday,Thursday,Friday).

Here's the shopping cart iteration from the preceding section, now with the forEach tag:

<c:forEach var="item" items="${sessionScope.cart.items}">

...
<tr>
<td align="right" bgcolor="#ffffff">
${item.quantity}
</td>
...
</c:forEach>

The forTokens tag is used to iterate over a collection of tokens separated by a delimiter.

URL Tags

2007 Aptech Ltd Version 1.0 Page 3 of 5

Web Programming with Servlets and JSP Knowledge Downloads

The jsp:include element provides for the inclusion of static and dynamic resources in the same context
as the current page. However, jsp:include cannot access resources that reside outside the Web
application, and it causes unnecessary buffering when the resource included is used by another element.
In the following example, the transform element uses the content of the included resource as the input of
its transformation. The jsp:include element reads the content of the response and writes it to the body
content of the enclosing transform element, which then rereads exactly the same content. It would be more
efficient if the transform element could access the input source directly and thereby avoid the buffering
involved in the body content of the transform tag.

<acme:transform>
<jsp:include page="/exec/employeesList"/>
<acme:transform/>

The import tag is therefore the simple, generic way to access URL-based resources, whose content can
then be included and or processed within the JSP page. For example, in XML Tag Library, import is used
to read in the XML document containing book information and assign the content to the scoped variable
xml:

<c:import url="/books.xml" var="xml" />

<x:parse doc="${xml}" var="booklist"
scope="application" />

The param tag, analogous to the jsp:param tag (see jsp:param Element), can be used with import to
specify request parameters.

In Session Tracking we discuss how an application must rewrite URLs to enable session tracking whenever
the client turns off cookies. You can use the url tag to rewrite URLs returned from a JSP page. The tag
includes the session ID in the URL only if cookies are disabled; otherwise, it returns the URL unchanged.
Note that this feature requires that the URL be relative. The url tag takes param subtags to include
parameters in the returned URL. For example, bookcatalog.jsp rewrites the URL used to add a book
to the shopping cart as follows:

<c:url var="url" value="/catalog" >

<c:param name="Add" value="${bookId}" />
</c:url>
<p><strong><a href="${url}">

The redirect tag sends an HTTP redirect to the client. The redirect tag takes param subtags for
including parameters in the returned URL.

Miscellaneous Tags
The catch tag provides a complement to the JSP error page mechanism. It allows page authors to recover
gracefully from error conditions that they can control. Actions that are of central importance to a page should
not be encapsulated in a catch; in this way their exceptions will propagate instead to an error page.
Actions with secondary importance to the page should be wrapped in a catch so that they never cause the
error page mechanism to be invoked.

The exception thrown is stored in the variable identified by var, which always has page scope. If no
exception occurred, the scoped variable identified by var is removed if it existed. If var is missing, the
exception is simply caught and not saved.

The out tag evaluates an expression and outputs the result of the evaluation to the current JspWriter
object. The syntax and attributes are as follows:

<c:out value="value" [escapeXml="{true|false}"]

[default="defaultValue"] />

2007 Aptech Ltd Version 1.0 Page 4 of 5

Web Programming with Servlets and JSP Knowledge Downloads

If the result of the evaluation is a java.io.Reader object, then data is first read from the Reader
object and then written into the current JspWriter object. The special processing associated with
Reader objects improves performance when a large amount of data must be read and then written to the
response.

If escapeXml is true, the character conversions listed in Table 14-4 are applied.

Table 14-4 Character Conversions

Character Character Entity Code

< &lt;
> &gt;

& &amp;
' &#039;

" &#034;

--- End of Article---

2007 Aptech Ltd Version 1.0 Page 5 of 5