An EL expression can be used to render a textual string in-line with template data—for example, as a constant EL arithmetic expression:

<b>There are ${5 + 1} bears in the cave.</b>

Another example demonstrates the use of EL to address a property of a nested JavaBeans:

<b>The total cost for this order is ${order.totals.afterTax}.</b>

EL expressions are also used for the attribute values of certain tags. Namely, EL expressions are frequently found in the attribute values of tags in the JSTL. For example, the <c:if> JSTL tag uses an EL logical expression for its test attribute value:

<c:if test="${salary > 100000}">
<b>Rich cousin!</b><br/>
</c:if>

To access the minQual property of a Java object called member, for example, use the following EL:

<b>You must earn ${member.minQual} points to maintain your membership.</b>

You can also use the equivalent [] notation:

<b>You must earn ${member["minQual"]} points to maintain your membership.</b>

The getMinQual() getter method of the object will be invoked to obtain the value to be rendered.

To access the ninth element in a Java array named callHistory, you can use the following EL:

<b>In the most recent call to the customer, ${callHistory[8]} is discussed .</b>

A Java Map typed object provides mapping between a set of keys and a set of values. Using EL, as long as the key values can be converted to strings, the elements in the Map can be directly accessed using EL.

For example, to access the value associated with the key "Mumbai" in a HashMap (a concrete implementation of a Java Map) called temperature, the following EL can be used:

<b>The temperature now is ${temperature.Mumbai}.  </b>

The following code is equivalent to the preceding code:

<b>The temperature now is ${temperature["Mumbai"]}.  </b>

EL can readily work with any Java Collection object (i.e. objects that implement the java.util.Collection interface). Iterative access is achieved in collaboration with JSTL's <c:forEach> tag (see Appendix C, "JSTL Reference"). Individual elements of a List- based collection can be accessed via the following EL:

<tr><td>${memberList[3]} </td></tr>

The preceding code will call the memberList.get(3) method and coerce the result to a string for rendering. The fourth element in the list will be displayed.

Any named variables within EL expressions are first checked against the available EL implicit objects (see the "Implicit Objects" section later in this appendix). If the named variable does not correspond to any implicit object, the EL runtime will search through the different scopes for an attribute with the specified name. It will search the scopes in the order of page

Literals are constants that can be used within EL. The following table shows the different types of literals available in EL.

Operators fall into four categories:

As with most programming languages, parentheses ( ) can be used to control the exact precedence of the operators.

Otherwise, the precedence follows this order:

Functions can be used within EL to transform values of variables or other expressions. The general syntax to call a function within EL is as follows:

xx:fname( arg1, arg2, ..... )

Here, xx is the prefix of a tag library that contains the EL function, fname is the name of the function, and arg1, arg2, .... is a list of arguments for the function.

EL functions must be packaged as part of a tag library.

${wf:rankOf(name, level)}

<%@ taglib prefix="wf" uri="http://www.wrox.com/begjsp/el-functions-taglib" %>

<function>
  <description>Function to determine a member's rank</description>
  <name>rankOf</name>
  <function-class>com.wrox.begjsp.ch15.ElFuncs</function-class>
  <function-signature>String rankOf(String,  int )</function-signature>
 </function>

Coercion, or automatic type conversion, occurs when the input type does not match the required type. For example, the attribute of a tag may require an integer value, but the input value is a string. Before this conversion can happen, EL will always first "box" a primitive type, as explained next.

This is the same as the JSP implicit object of the same name. The properties of this implicit object can be used to access the various JSP implicit objects.

For example, pageContext.request is the same as the request JSP implicit object, and pageContext.servletContext is the same as the JSP application implicit object. For more details on the available properties, see a description of the pageContext JSP implicit object in Appendix A.

The pageScope implicit object provides a map of all the available attributes in the page scope. In EL, values of a Map can be accessed via the [] notation or the. notation.

For example, to render the value of an attribute named selectedRow in the page scope, the following EL can be used:

${pageScope.selectedRow}

The following EL is equivalent:

${pageScope["selectedRow"]}

The requestScope implicit object provides a map of all the available attributes in the request scope. In EL, values of a map can be accessed via the [] notation or the dot (.) notation.

For example, to render the value of an attribute named currentCert in the request scope, the following EL can be used:

${requestScope.currentCert}

The following EL is equivalent:

${requestScope["currentCert"]}

Note that in some cases, if the incoming request is originating from another Web resource (for example, a PERL script), the name of the attribute may actually contain embedded dot (.) characters. In this case, you must use the second EL syntax shown above—the [] notation to access the value of the attribute.

The sessionScope implicit object provides a Map of all the available attributes in the session scope. In EL, values of a Map can be accessed via either the [] notation or the dot (.) notation.

For example, to render the value of an attribute named orderTotal in the session scope, the following EL can be used:

${sessionScope.orderTotal}

The following EL is equivalent:

${sessionScope["orderTotal"]}

The applicationScope implicit object provides a map of all the available attributes in the application scope. In EL, values of a map can be accessed via the [] notation or the dot (.) notation.

For example, to render the value of an attribute named productCategories in the application scope, the following EL can be used:

${applicationScope.productCategories}

The following EL is equivalent:

${applicationScope["productCategories"]}

The param implicit object is a map containing all the incoming request parameters. The keys of the map are the names of the parameters, and the values are the corresponding values. In EL, values of a map can be accessed via the [] notation or the dot (.) notation.

For example, to render the value of a request parameter named address1, the following EL can be used:

${param.address1}

The following EL is equivalent:

${param["address1"]}

The paramValues implicit object is a map providing access to all multivalued incoming request parameters. The keys of the map are the names of the parameters, and the values are arrays of strings (String []) with the corresponding values. In EL, values of a map can be accessed via the [] notation or the dot (.) notation.

For example, to access the values in a multivalued request parameter named itemsPurchased, the following EL can be used. Of course, you are likely to use <c:forEach> to iterate through the resulting array value.

${paramValues.itemsPurchased}

Equivalently, the following EL can also be used obtain the array:

${paramValues["itemsPurchased"]}

The header implicit object is a Map containing all the HTTP headers. The keys of the Map are the names of the headers, and the values are the corresponding header values. In EL, values of a Map can be accessed via the [] notation or the dot ( . ) notation.

For example, to render the value of the HTTP header User-Agent, the following EL can be used:

${header["User-Agent"]}

The headerValues implicit object is a Map providing access to all multivalued HTTP request headers. The keys of the Map are the names of the headers, and the values are arrays of strings (String []) with the corresponding values. In EL, values of a Map can be accessed via the [] notation or the dot (.) notation.

For example, to access the values in a multivalued HTTP header named Accept-Encoding, the following EL can be used. Of course, you are likely to use <c:forEach> to iterate through the resulting array.

${header["Accept-Encoding"]}

The cookies implicit object is a map containing all the values from available HTTP cookies with the request. The keys of the map are the names of the cookies, and the values are the corresponding values. In EL, values of a map can be accessed via either the [] notation or the dot (.) notation.

For example, to render the value of a cookie named lastLoginName, the following EL can be used:

${cookies.lastLoginName}

Equivalently, the following EL can also be used:

${cookies["lastLoginName"]}

Multiple cookies with the same name are not well supported by the implementation and should be avoided.

The initParam implicit object is a Map containing all the values from initialization parameters for the current ServletContext (specified through the web.xml deployment descriptor; see Chapter 15, "JSP and Servlets," for more details). The keys of the map are the names of the initialization parameters, and the values are the corresponding values. In EL, values of a map can be accessed via either the [] notation or the dot (.) notation.

For example, to render the value of an initialization parameter named localOffice, the following EL can be used:

${initParam.localOffice}

The following EL is equivalent:

${initParam["localOffice"]}