Inside the Brackets

There can be one of following inside the brackets of the [ ] operator:

• An index with or without quotes.
• A String literal.
• An EL implicit object or an attribute in any of the four scopes. The EL implicit object is explained later in this chapter.
• A nested expression.

If there is an index with or without quotes inside the brackets of the[ ] operator, the variable to which the [ ] operator is applied is either an array or a list. Listing 3-14 illustrates how to use the [ ] operator with a list or an array.

Listing 3-14. Using the [ ] Operator with a List or an Array

someArray["1"]
someArray[1]
someList["2"]
someList[2]

For example, the array in Listing 3-15 can be accessed as illustrated in Listing 3-16.

Listing 3-15. Setting an Array as an Attribute in the Servlet Code

1.   String [ ] books = {"Clojure", "Groovy ", "Java" , "Scala"} ;
2.   request.setAttribute("books", books);

Listing 3-16. Using the [ ] Operator

Book: ${books[0]}

The output displayed for Listing 3-16 is as follows:

Book: Clojure

If there is a String literal inside the brackets of the [ ] operator, the variable to which the [ ] operator is applied is either a JavaBean or a Map. Listing 3-17 illustrates the code for setting a Map as an attribute in the Servlet.

Listing 3-17. Code Fragment for Setting a Map as an Attribute in the Servlet Code

1.Map<String, String>  bookMap  = new HashMap<>();
2.bookMap.put("Groovy", "Beginning Groovy");
3.bookMap.put("Java", " Beginning Java");
4.bookMap.put("Scala", " Beginning Scala");
5.request.setAttribute("books", bookMap);

In Listing 3-18, EL searches for the attribute bound to the name books in the scope. In Listing 3-17, books is a Map set in the request attribute. Therefore, EL searches for the key Groovy passed in the [ ] operator of Listing 3-18 and evaluates it.

Listing 3-18. Using the [ ] Operator

Book : ${books["Groovy"] }

The output displayed for Listing 3-8 is as shown here:

Book: Beginning Groovy

Both . and [] operator can be used with JavaBeans or Maps. For example, Listing 3-18 could be written using the . operator as shown here:

${books.Groovy}

If there is neither a String literal nor an index with or without quotes inside the brackets of the [ ] operator and if the content inside the brackets of the [ ] operator is not an EL implicit object, then the content is evaluated by searching for an attribute with that name in any of the four scopes. This is illustrated using Listing 3-19 and Listing 3-20.

Listing 3-19. Code Fragment for Setting a Map as an Attribute in the Servlet Code

1.Map<String, String>  bookMap  = new HashMap<>();
2.bookMap.put("Groovy", "Beginning Groovy");
3.bookMap.put("Java", " Beginning Java");
4.bookMap.put("Scala", " Beginning Scala");
5.request.setAttribute("books", bookMap);
6.request.setAttribute("java", "Java");

Listing 3-20. Using the [ ] Operator

Book : ${books[java] }

Let’s see how the evaluation works in Listing 3-20.

• In the code${ books[java] } of  Listing 3-20, EL searches for an attribute bound by the name books in the scopes.
• EL finds this attribute in the request scope because books was set as a request attribute on line 5 in Listing 3-19.
• In Listing 3-20, the content of the [ ] operator is java, which is neither a String literal nor an EL implicit object; therefore, EL searches for an attribute bound by the name java in the scopes and finds it in the request scope because java was set as a request attribute on line 6 in Listing 3-19.
• Using the value Java of java on line 6 of Listing 3-19, the EL expression now becomes${ books["Java"] }.
• Now, because the books attribute is a Map set as a request attribute on line 5 in Listing 3-19, EL searches for the key Java, which is on line 3 in Listing 3-19. and prints its value as shown in the following output:

Book  : Beginning Java

If there is an EL expression inside the brackets of the [] operator, the content inside the brackets, which is an EL expression in this case, is evaluated by the same rules applied to any EL expression. In other words, if the EL expression is using the dot operator or [] operator and if it is a [] operator, then the same rules as explained previously are applied. This is illustrated using Listing 3-21 and Listing 3-22.

Listing 3-21. Code Fragment for Setting a Map and an Array as Attributes in the Servlet Code

1.Map<String, String>  bookMap  = new HashMap<>();
2.bookMap.put("Groovy", "Beginning Groovy");
3.bookMap.put("Java", " Beginning Java");
4.bookMap.put("Scala", " Beginning Scala");
5.request.setAttribute("books", bookMap);
6.
7.String[ ] categories = {"Groovy", "Java", "Scala"};
8.request.setAttribute("category", categories);

Listing 3-22. Nested EL Expression

Book : ${ books[category[1]] }

Here’s the output:

Book : Beginning Java

Now that you have learned how far you can go with the . and [ ] operators, it is time to see why EL is so important. You will now see why it is so important by completing the application you started to create, specifically, by writing the JSP page. Listing 3-23 illustrates book.jsp. This JSP page uses scripting elements (scriptlets and expressions) and EL. The idea is to compare the two, i.e. scripting elements and EL. This comparison is illustrated in Figure 3-7.

Listing 3-23. book.jsp

 1.<%@page import="com.apress.chapter03.model.Book"%>
 2.<%@page import="com.apress.chapter03.model.Author"%>
 3.<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
 4.<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c"%>
 5.<html>
 6.<head>
 7.</head>
 8.<body>
 9.<table border="1">
10.<tr>
11.<th width= "20px">Description</th>
12.<th >code</th>
13.<th >output</th>
14.</tr>
15.<%
16.Book book = (Book) request.getAttribute("bookAttrib");
17.Author author = book.getAuthor();
18.%>
19.<tr>
20.<td>Author's Name using <b>Scriptlet and Expression</b>
21.</td>
22.<td>${fn:escapeXml("<%= author.getName() %>")}</td>
23.<td><%=author.getName()%></td>
24.</tr>
25.
26.<jsp:useBean id="bookAttrib" class="com.apress.chapter03.model.Book"
27.scope="request" />
28.<tr>
29.<td>Author's Name using <b> jsp:getProperty action </b>
30.</td>
31.<td>
32.<table border="1">
33.<tr>
34.<td>${fn:escapeXml("<jsp:getProperty name = "bookAttrib " property= "author " />")}</td>
35.</tr>
36.<tr>
37.<td>${fn:escapeXml("<jsp:getProperty name = "bookAttrib " property= "author.name " />")}</td>
38.</tr>
39.</table>
40.
41.</td>
42.<td>
43.<table border="1">
44.<tr>
45.<td><jsp:getProperty name="bookAttrib" property="author" />
46.</td>
47.</tr>
48.<tr>
49.<td>
50.<%--  <jsp:getProperty name ="bookId" property="author.name" />  - this code will yield run time exception --%>
51.Not possible
52.</td>
53.</tr>
54.</table>
55.</td>
56.</tr>
57.<tr>
58.<td>Author's Name using<b> EL </b></td>
59.<td>${fn:escapeXml("${bookAttrib.author.name}")}</td>
60.<td>${bookAttrib.author.name}</td>
61.</tr>
62.</table>
63.</body>
64.</html>

• Line 23: This outputs the name of the author using expressions.
• Line 50: This shows that it is not possible to output the name of the author using a JSP standard action.
• Line 60: This outputs the name of the author using EL.

Figure 3-7 illustrates what you will see when you run this application (http://localhost:8080/chapter03/book). Essentially, it is just not possible to display the value of the name property of Author using a standard JSP action; scripting elements would have been the only way to do it, had it not been for EL.

Accessing Request Parameters

Listing 3-24 illustrates a simple form used to submit the request parameters through form.jsp.

Listing 3-24. form.jsp

 1.<body>
 2.<form action="books" method="post">
 3.<input type="hidden" name="action" value="books"/>
 4.<p>Book Title: <input type="text" name="bookTitle"></p>
 5.<p>Author 1 Name: <input type="text" name="authorName"></p>
 6.<p>Author 2 Name: <input type="text" name="authorName"></p>
 7.
 8.<input type = "submit"/>
 9.</form>
10.</body>

In Listing 3-24, the name property of the <input> tag is the same: authorName.

Listing 3-25 illustrates the usage of the EL implicit objects param and paramValues to retrieve the request parameter and display the result on the result.jsp page.

Listing 3-25. result.jsp

1.<p>Book Title: ${param.bookTitle}<br>
2.Author 1: ${paramValues.authorName[0]}<br>
3.Author 2: ${paramValues. authorName[1]}
4.</p>

• Line 1: This uses the EL implicit object param to get the Book title.
• Line 2 to Line 3: This code uses the EL implicit object paramValues to get the Author 1 and Author 2 names.

Accessing the Header

The EL implicit objects header and headerValues give you access to the header values that can be obtained using the request.getHeader() and request.getHeaders() methods.

Listing 3-26 illustrates accessing a header named user-agent, using the expression ${header.user-agent} or ${header["user-agent"]}.

Listing 3-26. Using EL Implicit Object Header

<span>${header["user-agent"]}</span>

Here’s the output:

Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0

Accessing Cookie

The El implicit object cookie gives us access to the cookie. Listing 3-27 illustrates the cookie stored in the servlet.

Listing 3-27. Setting a Cookie in a Servlet

1.String userName = "vishal";
2.Cookie c = new Cookie("userName", userName);
3.c.setPath("/");
4.response.addCookie(c);

Listing 3-28 illustrates how to use an EL implicit object to access the cookie in the JSP page.

Listing 3-28. Using an EL Implicit Object Cookie

${cookie.userName.value}

Accessing a Scoped Attribute

The El implicit object sessionScope gives access to the attribute stored in the session scope. Listing 3-29 illustrates the attribute stored in the session in a servlet.

Listing 3-29. Setting a Session Attribute in a Servlet

HttpSession session = request.getSession();
Book book = new Book();
book.setBookTitle("Beginning Java");
session.setAttribute("book", book);

Listing 3-30 illustrates using an EL implicit object called sessionScope to access the book title in the JSP page.

Listing 3-30. Using EL Implicit Object sessionScope

<span>Book title in Session Scope ${sessionScope.book.bookTitle}</span>

The <c:out> Action

The <c:out> action evaluates an expression and displays the result. It’s equivalent to the JSP syntax <%= expression %>.

Here’s the syntax without a body:

<c:out value="value" [escapeXml="{true|false}"][default="defaultValue"] />

Here’s the syntax with a body:

<c:out value="value" [escapeXml="{true|false}"]>
default value
</c:out>Items in brackets are optional

Table 3-8 describes the attributes of <c:out>. Since this chapter covers JSTL comprehensively, I recommend you read the JSTL specification³ for a thorough understanding of how to use JSTL attributes.

The value to be written to the JspWriter is specified as a value attribute. You can use expressions in the value attribute.

• value: The expression to be evaluated is supplied via the value attribute, and the result is converted into a string before being returned as part of the response.
• default: You can optionally specify a default value that <c:out> sends to the current JspWriter if the specified value is null or is not a valid expression. You can specify the default value with the default attribute or in the body of the <c:out> action.
• escapeXml: The escapeXml attribute specifies whether to convert certain characters to the HTML character entity codes listed in Table 3-9. By default, the escapeXmlattribute is set to true. If you specify false for the escapeXml attribute, <c:out> will not convert these characters.

Listing 3-35 illustrates replacing scripting elements with the <c:out> action.

Listing 3-35. Comparing  <c:out> and Expression

<%= "hello" %>  // Ouput "hello" using Expression
<c:out  value = "hello"/> // Ouput "hello" using <c:out> action

The <c:set>Action

The JSTL set tag or the <c:set> action sets the value of a scoped variable or a property of a target object. The <c:set> action is a better alternative to using the <jsp:setProperty> JSP action. Unlike <jsp:setProperty>, which allows you to set only the bean property, the <c:set> tag can do the following:

• Set bean properties
• Set Map values
• Create scoped variables on the page, request, session, or application scope

Table 3-10 describes the attributes of the <c:set> action.

The <c:set> tag is used to do the following:

• Set the value of a scoped variable in any JSP scope.
• Set a property of a specified target object. The target must evaluate to a JavaBean or Map object.

<c:set value=""value""var=""varName" " [scope=""{page|request|session|application}""]/>

<c:set var="helloVar" value="hello" />

<c:set var="helloVar" value="hello" scope="session" />

<c:set var="hello" scope="session" >
helloworld
</c:set>

<c:set var="titleVar" value="${book.title}" scope="session" />

<%
  String helloVar = "hello";
  pageContext.setAttribute("helloVar ", helloVar);
%>

<c:set value=""value""target=""target"" property=""propertyName""/>

<c:set target="bookMap" property="id" value="1">

<c:set target="book" property="book.title" value="Learning Java Web">

The <c:remove>Action

The <c:remove> action removes a variable from a specific scope. The variables set by <c:set> in any of the scopes can be removed using the <c:remove> action by specifying the variable name in the var attribute and the scope attribute.

Here’s the syntax:

<c:remove var="varName"[scope="{page|request|session|application}"]/>

Table 3-11 describes the attributes of the <c:remove> action.

Listing 3-43 illustrates the simple usage of <c:remove>.

Listing 3-43. Using <c:remove>

<c:remove var=" helloVar " />

The <c:catch> Action

The <c:catch> action provides a way to catch java.lang.Throwableexceptions that are thrown by any nested actions. This action has a single var attribute that holds a reference to any java.lang.Throwable exceptions that occur during the execution of any of the nested actions.

Here is the syntax:

<c:catch [var="varName"]>
...nested actions in the body...
</c:catch>

Table 3-12 describes the attribute of the <c:catch> action.

The <c:catch> action can handle errors from any action by nesting those actions within <c:catch>. When an exception is thrown, it is stored in a page-scoped variable that is identified by the var attribute of the tag. Listing 3-44 illustrates the usage of <c:catch>.

Listing 3-44. Using <c:catch>

<body>
 
<c:catch var = "exception">
<% int i = 1/0;%>
</c:catch>
 
<c:if test = "${exception != null}">
<span> Exception : ${exception}</span>
 
</c:if>
</body>

Here’s the output:

Exception : java.lang.ArithmeticException: / by zero

The <c:if>Action

The <c:if> action is used for conditional processing and evaluates an expression, displaying its body content only if the expression evaluates to true.

Here’s the syntax without body content:

<c:if test="testCondition"
var="varName" [scope="{page|request|session|application}"]/>

Here’s the syntax with body content:

<c:if test="testCondition"
[var="varName"] [scope="{page|request|session|application}"]>
. . . body content . . .
</c:if>

Using the test attribute, a Boolean EL expression is evaluated. If the test condition evaluates to true, only then the body of the action is executed. The Boolean result of the expression evaluation is exported to a scoped variable using the var attribute. The default scope of the var is page, but using the scope attribute, the scope could be set to any of the JSP scopes.

Table 3-14 illustrates the attributes of the <c:if> action.

Listing 3-45 illustrates using <c:if> with the body content.

Listing 3-45. Using <c:if> with Body Content

<c:set var="number" value="9"/>
<c:if test="${ number < 10}" >
<c:out value ="number is less than 10"/>
</c:if>

Here’s the output:

number is less than 10

The <c:choose>, <c:when>, and <c:otherwise> Actions

The <c:choose> action enables you to handle mutually exclusive conditions. It works like a Java switch statement and lets you choose between a number of alternatives, using <c:when> instead of case statements and <c:otherwise> to provide default action just like the switch statement does with a default clause.

The syntax for the <c:choose> action is as follows:

<c:choose>
body content (<c:when> and <c:otherwise>)
</c:choose>

As you can see, the <c:choose> action has two possible nested actions that form its body: <c:when> and <c:otherwise>. The syntax for each is as follows:

<c:when test="testCondition">
body
</c:when>
<c:otherwise>
body
</c:otherwise>

Table 3-15 illustrates the attributes of the <c:when> action.

Listing 3-46 illustrates a simple usage of <c:choose>.

Listing 3-46. Using <c:choose>

<body>
<c:set var="number" value="10"/>
<c:choose>
<c:when test="${number < 10}">
       Number is less than 10.
</c:when>
<c:when test="${number > 10}">
        Number is greater than 10.
</c:when>
<c:otherwise>
        Number is equal to 10
</c:otherwise>
</c:choose>
</body>

Here’s the output:

Number is equal to 10

The <c:forEach>Action

The <c:forEach> action iterates over a collection of objects.

Here’s the syntax for iterating over a collection of objects:

<c:forEach[var="varName"] items="collection"
[varStatus="varStatusName"]
[begin="begin"] [end="end"] [step="step"]>
. . . body content . . . .
</c:forEach>

Here’s the syntax for iterating a fixed number of times:

<c:forEach [var="varName"]
[varStatus="varStatusName"]
begin="begin" end="end" [step="step"]>
. . . . body content . . .
</c:forEach>

Table 3-17 illustrates the attributes of the <c:forEach> action.

To iterate over a collection of objects, use the following syntax:

<c:forEach[var="varName"] items="collection" [varStatus="varStatusName"]
...body  content ....
</c:forEach>

To iterate a fixed number of times, use the following syntax:

<c:forEach [var="varName"] [varStatus="varStatusName"]
begin="begin" end="end" [step="step"]>
...body content ...
</c:forEach>

Listing 3-47 illustrates a simple usage of <c:forEach>.

Listing 3-47. Using <c:forEach>

<body>
<c:forEach var="i" begin="1" end="3">
   Item <c:out value="${i}"/><p>
</c:forEach>
</body>

Here’s the output:

Item 1
Item 2
Item 3

The  <c:forTokens> Action

The <c:forTokens> action iterates over a string of tokens separated by a set of delimiters.

Here’s the syntax:

<c:forTokens items="stringOfTokens" delims="delimiters"
[var="varName"] [varStatus="varStatusName"]
[begin="begin"] [end="end"] [step="step"]>
. . . body . . . . . . . . .
</c:forTokens>

Table 3-18 describes all the attributes of <c:forTokens>.

The <c:forTokens> tag works with a string of characters separated by a delimiter. Listing 3-48 shows the usage of <c:forTokens>.

Listing 3-48. Using <c: for Tokens>

<body>
<c:forTokens items="Clojure,Groovy,Java, Scala" delims="," var="lang">
<c:out value="${lang}"/><p>
</c:forTokens>
</body>

Here is the output of Listing 3-48:

Clojure
Groovy
Java
Scala

The <c:import>Action

The <c:import> action imports the content of a URL-based resource, providing additional functionality over the <jsp:include> action. The syntax of the <c:import> action is as follows:

<c:import url ="url  [context="context"] [charEncoding="charEncoding"] [scope="application|page|request|session"] [var= "varName"] >
Optional body content for <c:param> sub tags
</c:import>

• The only required attribute is url, which is the URL of the resource to import.
• The <c:param> action, explained next, can be used as a nested tag in the body content of the <c:import>.

Table 3-20 describes all the attributes used with the <c:import> action.

In the previous chapter, we saw how the <jsp:include> action lets us encapsulate functionality in one JSP page and include it in another; for example, you could include a header and footer as illustrated in Listing 3-49.

Listing 3-49. Using the <jsp:include> Action

<body>
<jsp:include page='/WEB-INF/jsp/header.jsp'/>
<%-- content -%>
<jsp:include page='/WEB-INF/jsp/footer.jsp'/>
</body>

The <jsp:include> action is limited to including the resource that belongs to the same web application as the including page and specified as a relative URL.

You can use <c:import> instead of <jsp:include> to import resources in the same web application; Listing 3-50 illustrates how to use <c:import> instead of <jsp:include>.

Listing 3-50. Using <c:import>

<body>
<c:import url='/WEB-INF/jsp/header.jsp'/>
<%-- content --%>
<c:import url='/WEB-INF/jsp/footer.jsp'/>
</body>

With the <c:import> action, other than accessing resources in the same web application, you can also access external resources or resources in a foreign context. To access an external resource, you specify an absolute URL for the url attribute, and to access a resource in a foreign context, you specify a value for the context attribute that represents a context path for the foreign context along with the url attribute, which represents a context-relative path to the resource. Listing 3-51 illustrates how to use the <c:import> action to import a resource from a foreign context.

Listing 3-51. Importing a Resource from a Foreign Context

<c:import url='/jsp/book.jsp' context='/foreigncontext'/>

The <c:param>Action

The <c:import>, <c:url>, and <c:redirect> actions explained later in this section all deal with URLs. The <c:param> action is used to pass request parameters and is used as a nested tag in the body of either the <c:import>, <c:url>, or <c:redirect> action. The <c:param> action also does the URL encoding.

Here’s the syntax with a parameter value specified in the attribute value.

<c:param name="name" value="value"/>

Here’s the syntax with a parameter value specified in the body content.

<c:param name="name">
parameter value
</c:param>

Table 3-21 describes the attributes of <c:param>.

Listing 3-52 illustrated how you can use <c:import> instead of <jsp:include>. You can also specify request parameters for included files with the <jsp:param> action, as shown in Listing 3-52.

Listing 3-52. Using  <jsp:param>

<body>
<jsp:include page='/WEB-INF/jsp/company/companyHeader.jsp'>
<jsp:param name='user'
value='<%=session.getAttribute("userName")%>'/>
</jsp:include>
<%-- Page content goes here--%>
<jsp:include page='/WEB-INF/jsp/company/companyFooter.jsp'/>
</body>

Listing 3-53 illustrates how you can use <c:param> instead of <jsp:param>.

Listing 3-53. Using <c:param>

<body>
<c:import url='/WEB-INF/jsp/header.jsp'>
<c:param name='user'
value='${sessionScope.userName}'/>
</c:import>
<%-- body content --%>
<c:import url='/WEB-INF/jsp/footer.jsp'/>
</body>

The <c:url>Action

The <c:url> action builds a URL with the proper rewriting rules applied. It can format a URL and store it in a variable specified by the var attribute.

Here’s the syntax without body content:

<c:url value [context] [var] [scope]/>

Here’s the syntax with body content to specify query string parameters:

<c:url value [context] [var] [scope]>
<c:param> actions
</c:url>

• The only required attribute is value, which is the URL to be processed.
• <c:param> subtags can also be specified within the body of <c:url> for adding to the URL query string parameters, which will be properly encoded if necessary.

The attributed of <c:url> are listed in the Table 3-22.

Listing 3-54 shows the simple usage of <c:url>.

Listing 3-54. Using <c:url>

<c:url var="homePage" scope="session"value="http://www.yourbookstore.com" />

If you specify a context-relative or page-relative URL for the value attribute, <c:url> prepends the context path of the web application to the URL; for example, if the context path of the web application is /bookWeb/books, the <c:url> action <c:url value='/book.jsp'/> will result inurl:/bookWeb/books/book.jsp.

The <c:redirect>Action

The <c:redirect> action sends an HTTP redirect to the client, redirecting the browser to an alternate URL. The <c:redirect> action provides the URL rewriting with a redirect.

Here’s the syntax without body content:

<c:redirect url="value" [context="context"]/>

Here’s the syntax with body content to specify query string parameters:

<c:redirect url="value" [context="context"]>
<c:param> subtags
</c:redirect>

The <c:redirect>action has two attributes: the URL that will be used to redirect to and an optional context.

The attributes of <c:redirect> are listed in the Table 3-23.

The URL, relative or absolute, follows the same URL rewriting rules as <c:url>. Listing 3-55 illustrates redirecting to an external resource, which is an absolute URL.

Listing 3-55. Using <c:redirect>

<c:redirect url="http://www.yourbookstore.com" />

You can redirect to a resource in a foreign context using the context attribute. The URL specified must start with a / as a context-relative URL, and as defined, the context name must also start with a /. Listing 3-56 illustrates redirecting to a foreign resource in a foreign context.

Listing 3-56. redirecting to a foreign resource in a foreign context.

<c:redirect url="/foreignresource.html" context="/foreigncontext" />

In this chapter, we have looked at the nuts and bolts of the Java EE machine in the web tier: the web components (servlets and JSP), the feature-rich Expression Language, and the ready-to-use custom actions (JSTL). Now we’ll talk about best-practice solutions using patterns.