Home TOC

Core Tags

The core tags include those related to expressions, flow control, and a generic way to access URL-based resources whose content can then be included and or processed within the JSP page.

Table 2 Core Tags 

Area	Function	Tags	TLD	Prefix
Core	Expression Language Support	<expr> <set>	/jstl-c	c
	Flow Control	<forEach> <forEachToken> <if> <choose> <when> <otherwise>
	Import	<import> <param> <urlEncode>

Expression Tags

The expr tag evaluates an expression and outputs the result of the evaluation to the current JspWriter object. It is the equivalent of the JSP syntax <%= expression %>. For example, showcart.jsp displays the number of items in a shopping cart as follows:

<c:expr value="$session:cart.numberOfItems"/>
 

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

The JSP scoped attribute can be set either from attribute value:

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

or from the body of the tag:

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

The JSTL expression language reduces the need for scripting. However, page authors will still have to deal with situations where some attributes of non-JSTL tags must be specified as expressions in the page's scripting language. The standard JSP element jsp:useBean is used to declare a scripting variable that can be used in a scripting language expression or scriptlet. For example, showcart.jsp removes a book from a shopping cart using a scriptlet. The ID of the book to be removed is passed as a request parameter. The value of the request parameter is first set as a page attribute (to be used later by the JSTL sql:query tag) and then declared as scripting variable and passed to the cart.remove method:

<c:set var="bookId" value="$param:Remove"/>	
<jsp:useBean id="bookId" type="java.lang.String" />	
<% cart.remove(bookId); %>	
<sql:query var="books" dataSource="$bookDS">	
   select * from PUBLIC.books where id = ?	
   <sql:param value="$bookId" />	
</sql:query>
 

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:

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

Flow control tags eliminate the need for scriptlets.

Iterator Tags

The forEach tag allows you to iterate over a collection of objects.

Here's the iteration from the previous section using the forEach tag:

<c:forEach var="item" items="$session:cart.items">	
   ...	
   <tr> 	
      <td align="right" bgcolor="#ffffff"> 	
      <c:expr value="$item.quantity"/>	
   </td>	
   ...	
</c:forEach>
 

Conditional Tags

The if tag allows the conditional execution of its body according to value of a test attribute. The following example from catalog.jsp tests whether the request parameter Add is not 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="$param:Add != ''">	
   <c:set var="bid" value="$param:Add"/>	
   <c:declare id="bid"  type="java.lang.String" />	
    <sql:query var="books" dataSource="$bookDS">	
      select * from PUBLIC.books where id = ?	
      <sql:param value="$bid" />	
   </sql:query>	
   <c:forEach var="bookRow" begin="0" items="$books.rows"> 	
      <c:declare id="bookRow"	
         type="javax.servlet.jsp.jstl.sql.Row" />	
      <jsp:useBean id="addedBook"	
         class="database.BookDetails" scope="page" />	
   ...	
   <% cart.add(bid, addedBook); %>	
...	
</c:if>
 

The choose tag performs conditional block execution embedded by the when sub tags. 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 evaluate to true, then the body of an otherwise tag is evaluated, if present.

Import Tags

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 of the Web application and causes unnecessary buffering when the resource included is fed into another element

In the example below, 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, writes it to the body content of the enclosing transform element, which then re-reads the exact same content. It would be more efficient if the transform element could access the input source directly and 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. The param tag, analogous to the jsp:param tag (see Param Element), can be used with import to specify request parameters.

Home TOC