ZeePedia buy college essays online

Web Design and Development

<<< Previous JAVA: Expression Language Next >>>
Web Design & Development ­ CS506
Lesson 42
Expression Language
Sun Microsystems introduced the Servlet API, in the later half of 1997, positioning it as a powerful
alternative for CGI developers who were looking around for an elegant solution that was more efficient and
portable than CGI (Common Gateway Interface) programming. However, it soon became clear that the
Servlet API had its own drawbacks, with developers finding the solution difficult to implement, from the
perspective of code maintainability and extensibility. It is in some ways, this drawback that prompted the
community to explore a solution that would allow embedding Java Code in HTML ­ Java Server Pages
(JSP) emerged as a result of this exploration.
Java as the scripting language in JSP scares many people particularly web page designers which have
enough knowledge to work with HTML and some scripting language, faced lot of difficulties in writing
some simple lines of java code. Can we simplify this problem to ease the life of web designer? Yes, by
using Expression Language (EL).
JavaServer Pages Standard Tag Library (JSTL) 1.0 introduced the concept of the EL but it was constrained
to only the JSTL tags. With JSP 2.0 you can use the EL with template text.
Note: - JSTL will be discussed in the following Handout.
The Expression Language, not a programming or scripting language, provides a way to simplify
expressions in JSP. It is a simple language that is geared towards looking up objects, their properties and
performing simple operations on them. It is inspired form both the ECMAScript and the XPath expression
JSP Before and After EL
To add in motivational factor so that you start learning EL with renewed zeal and zest, a comparison is
given below that illustrates how EL affects the JSPs.
The following figure depicts the situation of a JSP before EL. We have to declare a variable before using it,
data type must be known in advance and most importantly have to use awkward syntax and many more. All
these problems are highlighted in the following figure:
Contrary to the above figure, have a look on the subsequent figure that gives you a hint how useful EL can
Person Name: $ { p.name }
<c:if test = "$ {p.address == param.add }" >
Expression Language Nuggets
We'll discuss the following important pieces of EL. These are:
Syntax of EL
Web Design & Development ­ CS506
Expressions & identifiers
Arithmetic, logical & relational operators
Automatic type conversion
Access to beans, arrays, lists & maps
Access to set of implicit objects
EL Syntax
The format of writing any EL expression is:
$ { validExpression }
The valid expressions can consist on these individuals or combination of these given below:
Variables (object references)
Implicit call to function using property name
EL Literals
The list of literals that can be used as an EL expression and their possible values are given in the tabular
format below:
Literal Values
true or false
Similar to Java e.g. 243, -9642
Floating Point
Similar to Java e.g. 54.67, 1.83
Any string delimited by single or double quote e.g.
"hello" , `hello'
Examples of using EL literals are: . ${ false } <%-- evaluates to false --%> . ${ 8*3 } <%-- evaluates to 24
EL Operators
The lists of operators that can be used in EL expression are given below:
+ -* / (div) % (mod)
&&(and) ||( or) !(not)
== (eq) != (ne) < (lt) > (gt) <= (le) >= (ge)
The empty operator is a prefix operation used to determine if a
value is null or empty. It returns a Boolean value.
Web Design & Development ­ CS506
Let us look at some examples that use operators as valid expression:
${ (6*5) + 5 } <%-- evaluate to 35 --%>
${ (x >= min) && (x <= max) }
${ empty name }
Returns true if name is
Empty string (""),
Null etc.
EL Identifiers
Identifiers in the expression language represent the names of objects stored in one of the JSP scopes:
page, request, session, or application. These types of objects are referred to scoped variables throughout
this handout.
EL has 11 reserved identifiers, corresponding to 11 implicit objects. All other identifiers assumed to refer
to scoped variables.
EL implicit Objects
The Expression Language defines a set of implicit objects given below in tabular format:
Implicit Object
The context for the JSP page, used to access the JSP
implicit objects such as request, response, session,
out, servletContext etc.
A Map associating names & values of page scoped
A Map associating names & values of request
scoped attributes
A Map associating names & values of session
scoped attributes
A Map associating names & values of application
scoped attributes
Maps a request parameter name to a single String
parameter value.
Maps a request parameter name to an array of
Maps a request header name to a single header
Maps a request header name to an array of value.
A Map storing the cookies accompanying the
request by name
A Map storing the context initialization parameters
of the web application by name
Examples of using implicit objects are:
Web Design & Development ­ CS506
. ${ pageContext.response } -Evaluates to response implicit object of JSP
. ${ param.name } -This expression is equivalent to calling
${ cookie.name.value } -Returns the value of the first cookie with the given
-Equivalent to if (cookie.getName().equals("name"){ String val =
cookie.getValue(); }
Example Code: Summation of Two Numbers using EL
This simple example demonstrates you the capabilities of EL. index.jsp is used to collect input for two
numbers and their sum is displayed on result.jsp using EL. Let's first see the code of index.jsp
<body> Enter two numbers to see their sum
<form action="result.jsp" >
First Number : <input type="text" name="num1" />
<br> Second  Number: <input type="text" name="num2" />
<input type="submit" value="Calculate Sum" />
<%-- The code to sum two numbers if we used scriptlet
String no1 = request .getParameter("num1");
String no2 = request .getParameter("num2");
int num1 = Integer.parseInt(no1);
int num2 = Integer.parseInt(no2);
Result is: <%= num1 + num2 %>
<%-- implicit Object param is used to access request
parameters By Using EL summing two numbers --
%> Result is: ${param.num1 + param.num2}
</body> </html>
EL Identifiers (cont.)
We had started our discussion on EL identifiers. Let's find out how these identifiers (variables) can be
stored/retrieved in/from different scopes.
Storing Scoped Variables
By using java code, either in pure servlet or in a scriptlet of JSP, we can store variables in a particular
scope. For example,
. Storing a variable in session scope using Java code
Assume that we have PersonInfo class and we want to store its object pin session scope then we can write
the following lines of code to accomplish that:
Web Design & Development ­ CS506
HttpSession ses = request.getSession(true);  PersonInfo p = new PersonInfo();
p.setName("ali"); ses.setAttribute("person" , p);
. Storing a variable in request scope using Java code
For the following lines of code, assume that request is of HttpServletRequest type. To store PersonInfo
object p in request scope, we'll write:
PersonInfo p = new PersonInfo(); p.setName("ali");
request.setAttribute("person" , p);
You must be thinking of some another method (with which you are already familiar) to store a variable in a
scope, certainly by using JSP action tags, we learned how to store a variable in any particular scope.
. Storing a variable in request scope using JSP action tag
If we want to store p of type PersonInfo in request scope by using JSP action tags, then we'll
<jsp:useBean id="p" class="PersonInfo" scope="request"/>
Later, you can change the properties of object p by using action tag as well. For example
<jsp:setProperty name="p" property="name" value="ali" />
Retrieving Scoped Variables
You are already very much familiar of retrieving any stored scoped variable by using java code and JSP
action tags. Here, we'll discuss how EL retrieves scoped variables. As already mentioned, identifiers in the
valid expression represent the names of objects stored in one of the JSP scopes: page, request, session and
When the expression language encounters an identifier, it searches for a scoped variable with that name
in page scope,
then in request scope,
then in session scope
and finally in application scope
Note: - If no such object is located in four scopes, null is returned.
For example, if we've stored PersonInfo object p in session scope by mean of any mechanism discussed
previously and have written the following EL expression to access the name property of p ${p.name}
Then EL searches for p first in page scope, then in request scope, then in session scope where it found p.
After that it calls p.getName() method. This is also shown in pictorial form below:
Web Design & Development ­ CS506
Web Design & Development ­ CS506
$ { "Hello" ${user.firstName} ${user.lastName} }
EL also supports automatic type conversion; as a result primitive can implicitly wrap and unwrap
into/from their corresponding java classes. For example
Most importantly, if object/identifier is null, no NullPointerException would be thrown. For
example. If the expression written is:
Assume that person is null, then no exception would be thrown and the result would also be null.
Using Expression Language
Expression Language can be used in following situations
As attribute values in standard & custom actions. E.g.
<jsp:setProperty id = "person" value = ${....} />
In template text ­ the value of the expression is inserted into the current output. E.g.
<h3> $ { ...... } </h3>
With JSTL (discussed in the next handout)
Example Code: AddressBook using EL
So far, we have shown you implementation of AddressBook example in number of different ways. This
time EL will be incorporated in this example. AddressBook code example consists on searchperson.jsp,
showperson.jsp, ControllerServlet, PersonInfo and PersonDAO classes. Let's look on the code of each of
these components:
The JavaBean used to represent one person record.
package vu;
import java.io.*;
public class PersonInfo implements Serializable{
private String name;
private String address;
private int phoneNum;
// no argument constructor
public PersonInfo() {
name = "";
address = "";
phoneNum = 0;
// setters
public void setName(String n){
name = n;
public void setAddress(String a){
address = a;
public void setPhoneNum(int pNo){
phoneNum = pNo;
Web Design & Development ­ CS506
// getters
public String getName( ){
return name;
public String getAddress( ){
return address;
public int getPhoneNum( ){
return phoneNum;
It is used to retrieve/search person records from database.
package vu; import java.util.*; import
java.sql.*; public class PersonDAO{
private Connection con;
// constructor
public PersonDAO() throws ClassNotFoundException , SQLException {
//used to establish connection with database
private void establishConnection() throws
ClassNotFoundException , SQLException
// establishing connection
String conUrl = "jdbc:odbc:PersonDSN";
con = DriverManager.getConnection(conUrl);
// used to search person records against name
public ArrayList retrievePersonList(Strin g pName)
throws SQLException {
ArrayList personList = new ArrayList();
String sql = " SELECT * FROM Person WHERE name = ?";
PreparedStatement pStmt = con.prepareStatement(sql);
pStmt.setString( 1, pName);
System.out.println("retrieve person list");
ResultSet rs = pStmt.executeQuery();
String name;
String add;
int pNo;
while ( rs.next() ) {
Web Design & Development ­ CS506
name = rs.getString("name");
add = rs.getString("address");
pNo = rs.getInt("phoneNumber");
// creating a PersonInfo object
PersonInfo personBean = new PersonInfo();
personBean.setName(name); personBean.setAddress(add);
// adding a bean to arraylist
} // end while
return personList;
} // end retrievePersonList
//overriding finalize method to release resources
public void finalize( ) {
if(con != null){
}catch(SQLException sex){
} // end finalize
} // end class
This JSP is used to gather person's name from the user and submits this data to the ControllerServlet.
<h2> Address Book </h2>
<h3> Search Person</h3>
<FORM name ="search" action="controllerservlet" />
<TD> <h4 >Name</h4> </TD>
<TD> <input type="text" name="name" /> </TD>
<input type="submit" value="search" /> <input type="reset"
value="clear" />
The Controller Servlet receives request from searchperson.jsp and after fetching search results from
database, forwards the request to showperson.jsp.
package controller;
Web Design & Development ­ CS506
import vu.*;
import java.io.*;
import java.net.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ControllerServlet extends HttpServlet {
} // end processRequest()
// This method only calls processRequest()
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
processRequest(request, response);
// This method only calls processRequest()
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
processRequest(request, response);
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws
ServletException, IOException {
// defined below
searchPerson(request, response);
} // end ControllerServlet
protected void searchPerson(HttpServletRequest request,
HttpServletResponse response) throws
ServletException, IOException {
try {
// creating PersonDAO object
PersonDAO pDAO = new PersonDAO();
// retrieving request parameter "name" entered on showperson.jsp
String pName = request.getParameter("name");
// calling DAO method to retrieve personlist from database // against the name entered
by the user
ArrayList personList = pDAO.retrievePersonList(pName);
// storing personlist in request scope, later it is retrieved // back on showperson.jsp
request.setAttribute("plist", personList);
// forwarding request to showperson, so it renders personlist
Web Design & Development ­ CS506
RequestDispatcher rd =  request.getRequestDispatcher("showperson.jsp");
rd.forward(request, response);
}catch (Exception ex) {
System.out.println("Exception is" + ex);
} // end searchPerson
This page is used to display the search results. To do so, it reclaims the stored ArrayList (personList) from
the request scope. Furthermore, this page also uses the Expression Language to display records.
<%-- importing required packages--%>
<%@page import="java.util.*" %>
<%@page import="vu.*" %>
<h2> Address Book </h2>
<h3> Following results meet your search criteria</h3>
<%-- start of scriptlet --%>
// retrieving ArrayList from request scope
ArrayList personList =(ArrayList)request.getAttribute("plist");
PersonInfo person = null;
for(int i=0; i<personList.size(); i++) {
person = (PersonInfo)personList.get(i);
// storing PersonInfo object in request scope /* As mentioned, an object must be
stored in some scope to work with Expression Language*/
request.setAttribute("p", person);
<%-- end of scriptlet --%>
<%-- accessing properties of stored PersonInfo object with name "p" using EL --%>
<TD> ${ p.name } </TD> <TD> ${ p.address} </TD>
<TD> ${ p.phoneNum} </TD>
<%-- The following expressions are now replaced by EL statements written above--%>
<%--<%= person.getName()%> --%> <%--<%=
person.getAddress()%> --%> <%--<%=
Web Design & Development ­ CS506
person.getPhoneNum()%> --%>
} // end for
<?xml version="1.0" encoding="UTF-8"?>
<servlet-name> ControllerServlet </servlet-name>
<servlet-class> controller.ControllerServlet </servlet-class>
<servlet-name> ControllerServlet </servlet-name>
<url-pattern> /controllerservlet </url-pattern>
. Java A Lab Course by Umair Javed.
. Expression Language Tutorial by Sun
The JSTL Expression Language by David M. Geary