evolution of jsp€¦ · package the javax.servlet.jsp.jsppage interface contains 2 methods public...

Evolution of JSP

CGI-Common Gateway Interface Complex Process management

Not Scalable

Servlet Java code

JSP No java code

Embed with HTML

Anand & Bhautik

JSP

Java Server Page is a server-side program

that is similar in design and functionality to a

Java Servlet.

JSP file has extension .jsp

JSP tags <% %>

Anand & Bhautik

How JSP file is executed?

Web server

Servlet Engine

JSP Engine

JSP documents

Compiled

servlet

HTML

documents

HTTP Request HTTP Response

Anand & Bhautik

Steps:

The client sends request to the browser

The server sends JSP file to JSP engine

It converts to servlet, compile for the first time and then load.

The servlet runs and generates HTML

The server sends HTML to browser

Anand & Bhautik

JSP vs ASP

JSP are translated once to byte code.

They are interpreted when file is

modified.

ASP are compiled every time

JSP runs on all web servers

ASP runs on Microsoft web server

cc

Anand & Bhautik

JSP Vs Servlet

JSP is on top of servlet API.

Servlet provides dynamic contents

using java code

JSP also provides dynamic contents

but is simpler to write than servlet

Anand & Bhautik

JSP Life Cycle

The lifecycle of JSP is controlled by three

methods which are automatically called

when a JSP is requested and when the

JSP terminates normally. These are:

jspInit ()

_jspService()

jspDestroy()

Anand & Bhautik

Init()

jspInit() method is identical to the init()

method in a Java Servlet and in applet.

It is called first when the JSP is requested

and is used to initialize objects and

variables that are used throughout the life

of the JSP.

Anand & Bhautik

Service()

_jspService() method is automatically

called and retrieves a connection to HTTP.

It will call doGet or doPost() method of

servlet created.

Anand & Bhautik

Destroy()

jspDestroy() method is identical to the destroy() method in Servlet.

The destroy() method is automatically called when the JSP terminates normally.

It isn’t called by JSP when it terminates abruptly.

It is used for cleanup where resources used during the execution of the JSP ate released, such as disconnecting form database.

Anand & Bhautik

Package

The javax.servlet.jsp.JspPage interface contains 2 methods

public void jspInit()

It is invoked when JSP is first initialized.

public void jspDestroy()

It is invoked when JSP is about to be destroyed by the container.

The javax.servlet.jsp.HttpJspPage interface contains 1 method

public void _jspService(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException

Anand & Bhautik

Life cycle

Initialize

public void jspInit()

Destroy

public void jspDestroy()

Handles client requests and generate responses

void _jspService(HttpServletRequest req,HttpServletResponse)

throws ServletException, IOException

Anand & Bhautik

JSP Elements

Element is that part of code which is

processes on the server. There are three

types of JSP Elements:

Directive Elements

Scripting Elements

Action Elements

Anand & Bhautik

Directive Elements:

JSP directive serve as message to the JSP

container for the JSP.

They are used to set global values such as class

declaration, methods to be implemented, output

content type etc.

They do not produce any output to the client.

All directives have scope of the entire JSP file.

Anand & Bhautik

Syntax

Directives are characterized by @ character

within the tag.

Syntax:

<%@ directivename attribute=”value”

attribute=”value” %>

Anand & Bhautik

Types of Directive

The two directives are:

The page directive

The include directive

Anand & Bhautik

Page Directive

The page directive defines a number of

important attributes that affect the whole page.

A single JSP can contain multiple page

directives.

There can be only one occurrence of any

attribute/value pair defines by page directive

except import attribute.

<% @ page ATTRIBUTES %>

Anand & Bhautik

Page directive Attributes

Attribute Description Default

Language Defines the scripting language to be

used.

“java”

Extends It is fully qualified class name of super class

that the generated class must extend

Omitted

Import Comma separated list of packages or classes. Omitted

Session Specifies if the page participated in an

HTTP session

“true”

Buffer If value is “none” then no buffering occurs

and all o/p is written directly. If buffer size is

specified then o/p is buffered with buffer size

not less than that specifed

8KB

Anand & Bhautik

Contd.

Autoflush If true, buffer is flushed automatically

when it is full If false, a runtime exception

is thrown to indicate buffer overflow

“true”

isThreadSafe If “false”, it processes them one at a time

implementing

singleThreadModel interface

“true”

Info Defines informative string Omitted

isErrorPage If “true”, then implicit object exception is

available which is instance of class

java.lang.Throwable

“false”

ErrorPage Define a URL to another JSP that is

invoked if an unchecked runtime

exception is thrown omitted

Omitted

contentType Define MIME type for the response of the

JSP page.

text/html

Anand & Bhautik

Example

<%@page language=”java”

import=”java.sql.*” buffer=”12kb”

errorPage=”error.jsp” %>

Anand & Bhautik

The include Directive

This directive notifies the container to include the content of the resource in the current JSP, inline, at the specified place.

The contents of the included file are parsed by the JSP and this happens only at translation time.

The included page should not be another dynamic page.

<%@ include file=”filename” %>

Anand & Bhautik

Attributes Description

file The static filename to include

E.g.:

<%@ include file=”header.html” %>

Anand & Bhautik

Scripting Elements

Scripting elements are used to include

scripting code within the JSP.

They allow users to:

declare variables and methods

include arbitrary scripting code

evaluate an expression.

Anand & Bhautik

Types of scripting elements

The three types of scripting elements are:

Declaration <%! %>

Scriplets <% %>

Expression <%= %>

Anand & Bhautik

Declaration

A declaration is a block of java code in a JSP that

is used to define class wide variable and method in

generated class file.

Declarations are initialized when the JSP page is

initialized and have “class” expression or code.

A declaration block is enclosed between <%! %>

<%! Java variable and method declaration (s) %>

Anand & Bhautik

Example

<html>

<body>

<%!int i=0;

public mymethod();%>

</body>

</html>

Anand & Bhautik

Scriplet

A scriplet is a block of code that is executed at request processing time

.

A scriplet is enclosed between <% and %>

JSP get compiled into a servlet and all the code appearing between <% and %> in the JSP, put into the _jspService() method to this servlet.

<% Java code %>

Anand & Bhautik

Example

<html>

<body>

<%

for(int I=0;I<10;I++)

{

out.println(“<b> Hello”+ i +”</b>”);

}

%>

</body>

</html>

Anand & Bhautik

Expression

An expression is a shorthand notation for a

scriplet that outputs a value in the response

stream to the client.

When the expression is evaluated, the result is

converted to a string and displayed.

An expression is enclosed within <%= %>.

<%= Java expression to be evaluated %>

Anand & Bhautik

Example

<html>

<body>

<%! int i=0;%>

<%

i++;

%>

<%= “This page is accessed “ + i +”times” %>

</body>

</html>

Anand & Bhautik

Action Elements

Actions are specific tags that affect the runtime behavior of the JSP and affect the response sent back to the client.

The standard action types are:

<jsp:param>

<jsp:include>

<jsp:forward>

<jsp:plugin>

Anand & Bhautik

<jsp:param>

The <jsp:param> action is used to

provide other tags with additional

information in the form of name value

pairs.

This action is used in conjunction with

jsp:include, jsp:forward and jsp:plugin

actions.

Anand & Bhautik

Attributes

Attribute Description

Name

value

The key associated with the attribute

The value of the attribute

<jsp:param name=”t1” value=”abc” >

Anand & Bhautik

<jsp:include>

This action allows a static or dynamic resource to be include in the current JSP at request time.

The resource is specified using the URL format as include directive.

As included page has access only to the JspWriter object and it cannot set header and cookies. A request time exception is thrown if this is attempted.

If page is buffered then the buffer is flushed prior to the inclusion.

<jsp:include page= “filename” flush = “true” />

Anand & Bhautik

<jsp:include page= “/header.jsp” flush = “true” >

<jsp:param name=”t1” value=”abc” >

</jsp:include>

A jsp:include action may have one or more jsp:param tags in its body, to provide additional name-value pairs.

The included page can access the original request object, with both the original and the new parameters.

If the parameter names are same, the old values are kept intact, but the new values take precedence over existing values. (t1=abc,def,xyz).

Anand & Bhautik

Attributes

Attribute Description

Filename

flush

The resource to include

The value must be true

Anand & Bhautik

Attributes

Include Syntax Done when Included

content

Parsing

Directive

Action

<%@include file=”filename”%>

<jsp:include page=”filename”%>

Compilation

time

Request

Processing

time

Static

Static

or dynamic

Container

Not

Parsed but

included in

container

Anand & Bhautik

<jsp:forward>

The jsp:forward action allows the request to be forwarded to another JSP, a servlet or a static resource.

<jsp:forward page= “url” />

or

<jsp:forward page=”url”>

<jsp:parame name=”paramname” value=”val”/>

</jsp:forward>

Anand & Bhautik

example

Execution in current JSP stops when it encounters jsp:forward tag.

The buffer is cleared. If output stream was not bufferd and some output has been written to it, a jsp:forward action will throw a java.lang.IllegalStateException.

Example

<jsp:forward page=”/search/results.jsp” />

Anand & Bhautik

<jsp:plugin>

The jsp:plugin action is used to generate client browser specific HTML tags that ensures java plug-in software is available, followed by execution of the applet or Java Bean component specified in the tag.

The jsp:plugin tag can have two optional tags

<jsp:param> to pass additional parameters

<jsp:fallback> to specify the contents to be displayed if plug-in cannot be started.

Anand & Bhautik

Attribute Details Required

Type Applet/bean yes

code Name of class file Yes

codebase Path where class file is saved No

align Alignment on screen No

height Height of window No

width Width of window No

hspace Horizontal space No

vspace Vertical Space No

title Title of window No

name Name of window No

nspluginurl URL where JRE plugin can be downloaded for

Netscape Navigator

Only if java plugin s/w needs to

be installed

iepluginurl URL where JRE plugin can be downloaded for

internet explorer

Only if java plugin s/w needs to

be installed

Anand & Bhautik

Example

<html>

<body>

<jsp:plugin type=”applet” code=”app” codebase=”/classes/applet” height=”100” width=”100”>

<jsp:params>

<jsp:param name=’color” value=”black”/>

</jsp:params>

<jsp:fallback>Browser could not support</jsp:fallback>

</jsp:plugin>

</body>

</html>

Anand & Bhautik

Comments and Template

Data

Comments

Comments are useful to people building and maintaining pages.

They are useful to authors but useless for readers.

HTML comments are regular part of the document, it shows up if users use “view source” in the browser

This makes the download time a tiny fraction of second longer. A more serious concern is that sometimes HTML comments contain implementation details that might be confidential.

Anand & Bhautik

JSP’s solution is to replace the above HTML comments with a JSP comments, like

<%-- --%>

When JSP engine sees this tag, it recognizes it as comment and does not put into the servlet it builds.

The comments will thus never be sent to the user and will not show up when the user does a view source.

Anand & Bhautik

Template

The index page consists of three sections:

The header

The navigation area

The content area.

Different pages have different contents but it is reasonable to except that header and navigation will be repeated over the site.

It would be headache because developers need to place everything in its place. The cure of this nightmare is called Templating.

Anand & Bhautik

Template is HTML page with some spaces where

text should be, and somewhere to indicate where

text can be found.

This makes it possible to keep header in exactly

one file and let each page have a space that this

file should fill.

<%@ inlcude file=/header.jsp”<tr>

Anand & Bhautik

Implicit Objects

JSP tries to simplify the work of developers and provides certain implicit objects accessible within the JSP.

These objects do not need to be declared or instantiated by the JSP author, but are provided by the container in the implementation class.

All implicit objects are available only to scriplets or expression and are not available in the declaration. They are only available in _jspService() method of generated servlet.

Anand & Bhautik

Implicit Objects

request

response

out

session

config

exception

application

Anand & Bhautik

request

The request object has request scope, and

is the instance of

javax.servlet.ServletRequest.

It encapsulates the request coming from the

client and being processed by the JSP. It is

passed to the JSP by the container, as a

parameter to the _jspService() method.

Anand & Bhautik

HttpServletRequest

getParameter()

getParameterNames()

getParameterValues()

getHeaders()

getQueryString()

getRemoteAddr()

getRemoteHost()

getAttribute()

setAttribute()

getAttributeNames()

getCookies()

getSession()

Anand & Bhautik

response

The response object has page scope, and is the instance of class javax.servlet.ServletResponse

It encapsulates the response generated by the JSP, to be sent back to the client in response to the request.

It is generated by the container and passed it the JSP as parameter to the _jspService() method, where it is modified by the JSP.

Anand & Bhautik

HttpServletResponse

getWriter()

setContentType()

addCookie()

encodeURL()

sendRedirect()

setHeader()

setStatus()

Anand & Bhautik

out

The out object has page scope, and is an instance of class javax.servlet.jsp.JspWriter.

It represents the output stream opened back to the client. This is the PrintWriter used to send output to the client.

However in order to make the response object useful, this is buffered version of PrintWriter called JspWriter

Anand & Bhautik

session

The session object has session scope, and is an instance of class javax.servlet.http.HttpSession.

It represents the session created for the requesting client, and is only valid for HTTP requests.

Sessions are created automatically, so this variable exists even if there was no incoming session reference.

The one exception is if user uses session attribute of the page directive to turn sessions off, in which case attempts to reference the session variable cause translation errors for the JSP.

<%@page session=“true”%>

Anand & Bhautik

HttpSession

setAttribute()

getAttribute()

getAttributeNames()

removeAttribute()

getId()

getCreationTime()

getLastAccessedTime()

setMaxInactiveInterval()

isNew()

invalidate()

Anand & Bhautik

config

The config object has page scope, and is the instance of class javax.servlet.ServletConfig.

It represents the servlet configuration.

Example

<%

ServletContext sc=config.getServletContext();

RequestDispatcher rd=sc.getRequestDispatcher(“/new.jsp”);

rd.forward(request,response);

%>

Anand & Bhautik

ServletConfig

It is used to pass initialization and context

information to servlets

Methods

public abstract String getInitParameter(String name)

public abstract Enumeration getInitParameterNames()

Public abstract ServletContext getServletContext()

Anand & Bhautik

application

The application object has application

scope, and is the instance of class

javax.servlet.ServletContext.

It represents the context within which the

JSP is executing

Anand & Bhautik

ServletContext

getContext()

getServerInfo()

getInitParameter()

getInitParameterNames()

getAttribute()

setAttribute()

removeAttribute()

getRequestDispatcher()

Anand & Bhautik

Objects in JSP

Objects

request

response

out

session

config

application

interface

ServletRequest

ServletResponse

JspWriter

HttpSession

ServletConfig

ServletContext

Anand & Bhautik

Error handling in JSP

Types of error and exception

There are 2 types of exception

Translation time errors

Run Time Exception

Translation error occurs during page compilation, this results in an Internal Server Error (500).

An exception on other hand occurs when page is compiled and servlet is running.

Anand & Bhautik

Exception handling

The J2EE platform offers a great deal of control

over how to format error information when a web

component throws an unexpected exception.

Exception can be handled in JSP in three ways:

Dealing with exception with page directive

Dealing with exception in Deployment

Descriptor

Java Exception Handling mechanism

Anand & Bhautik

Dealing with exception

with page directive

The error page can be used to display a

more user-friendly error message. Page

Directive can be used to handle exception.

Two attributes of page directive errorPage

and isErrorPage are used to deal with

exception

Anand & Bhautik

Attributes

isErrorPage If “true”, then implicit object exception is available which is instance of class java.lang.Throwable

errorPage Define a URL to another JSP that is invoked if an unchecked runtime exception is thrown

Anand & Bhautik

Following methods are used with exception

object of class Throwable

public String getMessage()

public String getLocalizedMessage()

public StackTrace printStackTrace( )

Anand & Bhautik

exception

The exception object has page scope, and is

the instance of class java.lang.Throwable.

It refers to the runtime exception that

resulted in the error page being invoked, and

is available only in the error page (a page in

which isErrorPage=true)

Anand & Bhautik

example

<@page isErrorPage=”true”%>

<html>

<body>

The server has encountered following error

Exception<%=exception%>

Message<%=exception.getMessage()%>

Local Message<%= exception.getLocalizedMessage()%>

</body>

<html>

Anand & Bhautik

Dealing with exception in

Deployment Descriptor

The Web application deployment descriptor (web.xml) uses the <error-page> tag to define Web components that handle errors.

When an error occurs Web Server returns an HTML page that displays

either the HTTP error code or a page containing the Java error message.

You can define your own HTML page to be displayed in place of these default error pages or in response to a Java exception.

Anand & Bhautik

Three elements can be used with error-page:

<exception-type> It is an optional element. A fully

qualified class name of java exception type.

<error-code> It is also an optional element and

contains a valid HTTP error code.

<location> It is required field. It specifies the

location of resource to display in response to the

error

Anand & Bhautik

Example

<error-page>

<exception-type>java.lang.NullPointerException </exception-type>

<location>/error.html</location>

</error-page>

//error.html

<html><body>

<h1>There is some internal problem is a server</h1>

</body>

</html>

Anand & Bhautik

Using JSP error page

JSP pages, being web component, allow user to report not only an error that has occurred, but also what went wrong.

<error-page>

<exception-type>java.lang.SQLException</exception-type>

<location>/error.jsp</location>

</error-page>

Anand & Bhautik

error.jsp

<@page isErrorPage=”true”%>

<html><body>

The server has encountered following error

<%=exception%>

<%=exception.getMessage%>

<%= exception.getLocalizedMessage%>

<%= exception.printStackTrace()%>

</body>

<html>

Anand & Bhautik

Java Exception Handling

mechanism

The jsp1.1 specification added two java.lang.Exception subclasses JspException

• The JspException class represents a generic exception for the JSP packages. It can be found in the javax.servlet.jsp package.

JspError• The JspError class in the javax.servlet.jsp package is the

only predefined subclass of JspExcepton. It is meant to represent an unrecoverable error.

Anand & Bhautik

Class Hierarchy

Throwable

Error Exception

JspException

JspError

Anand & Bhautik

Example

<%

try

{

//jsp code

}

catch(JspException e)

{

out.println(e);

}

%>

Anand & Bhautik

Scope of JSP variable

Scope is the region in which variable is

accessible

Page scope

Request Scope

Session scope

Application scope

Anand & Bhautik

Page scope

Any object whose scope is the page will disappear as soon as the current page finishes generating.

It is equivalent to local scope but it is implemented differently.

An object with page scope may be modified as often as desired within the page, but all these changes will be lost when page exists.

Anand & Bhautik

Request scope

The second kind of scope is associated with request object.

The first page can place any information into the request scope, and the second page can look for the information and act on it.

One way to put data into the request scope is to do it manually by setting value using setAttribute() method and retrieves the value on forwarded page using getAttribute() method of HttpServletRequest.

Anand & Bhautik

Example

<%

request.setAttribute(“name”,request.getParameter(“t1”))

%>

<jsp:forward page=”/login.jsp”/>

name variable is used as long as request is chained

login.jsp

<html>

<body>

User id:<%=request.getAttribute(“name”)%> </body>

</html>

Anand & Bhautik

Session scope

Since user, not pages are really the focus of the site,

E.g.: Multiple users can see the same checkout page of shopping site, but each user sees his own selection.

In JSP terms data associated wit ha user is in the session scope.

A session does not correspond directly to a user; rather, it corresponds with a particular period of time the user spends at a site.

Anand & Bhautik

example

<%

session.setAttribute(“name”,request.getParameter(“t1”))

%>

<jsp:forward page=”/login.jsp”/>

name variable is used until user sign out

login.jsp

<html>

<body>

User id:<%=session.getAttribute(“name”)%> </body>

</html>

Anand & Bhautik

Application scope

There is one scope even bigger than

session scope, the application scope,

which extends across all users and all

pages.

It is useful for keeping data that multiple

users will see and appear on multiple

pages.

Anand & Bhautik

example

<%

application.setAttribute(“name”,request.getParameter(“t1”))

%>

<jsp:forward page=”/login.jsp”/>

name variable is used until user closes site

login.jsp

<html>

<body>

User id:<%=application.getAttribute(“name”)%> </body>

</html>

Anand & Bhautik

Implicit object scope

Objects

request

response

out

session

config

application

exception

Scope

request

Page

Page

Session

page

Application

page

Anand & Bhautik

Expression

language

Introduction

EL

Anand & Bhautik

Why EL?

Debugging and Maintaining site was

difficult.

Mix of HTML and scriplets (no separation

between presentation and logic)

MVC (Model-view-Controller)

EJB JSP BLTo create multiple views on same code

there is a need to separate logic and

view

Anand & Bhautik

JSP 2.0 incorporates the Expression

Language (EL) first introduced in JSTL

1.0.

EL makes it easier to integrate server-side

state with presentation output.

Anand & Bhautik

JSP 2.0 EL

The JSP 2.0 Expression Language (EL) is a

much-needed feature for Web developers who

want to build scriptless JSP pages.

It was designed as a part of the JSP Standard

Tag Library (JSTL) 1.0, and then JavaServer

Pages (JSP) 2.0 adopted and enhanced the EL.

Anand & Bhautik

JSP 2.0 EL

The expression language is an extension of the JSTL 1.0 EL,

that adds several new features.

The syntax of the expression language is simpler than a

custom tag, and usually requires no associated Java code.

Also, the expression language automatically handles

typecasting, null values, and error handling.

Anand & Bhautik

The EL defines an easy-to-use syntax for

accessing:

JavaBean properties

Scoped attributes

Initialization and request parameters

HTTP headers and cookies without using Java

scriptlets in JSP pages.

This makes the code more readable and

improves the maintainability of the Web pages.

Properties

Anand & Bhautik

EL has predefined Set of:

EL expression

Variable

Implicit objects

Literals and keywords

Operators

Anand & Bhautik

EL Expression

Expressions used to set attribute values are evaluated in the context of an expected type.

A JSP 2.0 EL expression is always written between the delimiters ${ and }.

If the result of the expression evaluation does not match the expected type exactly, a type conversion will be performed.

Anand & Bhautik

EL Variables

Variables are accessed by name.

Type conversion is automatic from the

variable's native type to a type that is

compatible with the requested operation.

Anand & Bhautik

Implicit objects

The JSP expression language defines a set of implicit objects:

pageContext: The context for the JSP page. Provides access to various objects including

servletContext: The context for the JSP page's servlet and any web components contained in the same application.

session: The session object for the client.

request: The request triggering the execution of the JSP page..

response: The response returned by the JSP page.

Anand & Bhautik

param: Maps a request parameter name to a single value

paramValues: Maps a request parameter name to an array of values

header: Maps a request header name to a single value

headerValues: Maps a request header name to an array of values

cookie: Maps a cookie name to a single cookie

initParam: Maps a context initialization parameter name to a single value

Anand & Bhautik

Scope Object

pageScope: Maps page-scoped variable names to their values

requestScope: Maps request-scoped variable names to their values

sessionScope: Maps session-scoped variable names to their values

applicationScope: Maps application-scoped variable names to their values

Anand & Bhautik

“.” operator

The "." operator is shorthand for calling a JavaBeans property

accessor for the property whose name is on the right-hand side

of the operator.

For example, the following expression in the sample page:

${pageContext.servletContext.servletContextName

}

actually executes as:

pageContext.getServletContext().getServletContext

Name()

Anand & Bhautik

[] operator

The [] operator is a polymorphic indexing operator that can

be used to index collections

The value inside the brackets is used as a key into a map, or

as a List or array index.

Eg:

${header["host"]} localhost:8080

${header["user-agent"]} Mozilla/5.0 (Macintosh;...)

Anand & Bhautik

Literals and Keywords

The JSP expression language defines the following literals:

Boolean: true and false

Integer: as in Java

Floating point: as in Java

String: with single and double quotes; " is escaped as \", ' is

escaped as \', and \ is escaped as \\.

Null: null

Reserved Words

The following words are reserved for the JSP expression

language and should not be used as identifiers.

and eq gt true instanceof or ne le false empty

not lt ge null div mod

Anand & Bhautik

operators

Arithmetic: +, - (binary), *, / and div, % and mod, - (unary)

Logical: and, &&, or, ||, not, !

Relational: ==, eq, !=, ne, <, lt, >, gt, <=, ge, >=, le.

Empty: The empty operator is a prefix operation that can be used to determine whether a value is null or empty.

Conditional: A ? B : C. Evaluate B or C, depending on the result of the evaluation of A.

Anand & Bhautik

The precedence of

operators

The precedence of operators highest to lowest, left to right is as follows:

[] .

() - Used to change the precedence of operators.

- (unary) not ! empty

* / div % mod

+ - (binary)

< > <= >= lt gt le ge

== != eq ne

&& and

|| or

? :

Anand & Bhautik

EL Expression Result

${1 > (4/2)} false

${4.0 >= 3} true

${100.0 == 100} true

${(10*10) ne 100} false

${'a' < 'b'} true

${'hip' gt 'hit‘} false

${4 > 3} true

${1.2E4 + 1.4} 12001.4

${3 div 4} 0.75

${10 mod 4} 2

${empty param.t1} True if the request parameter named t1 is null or an empty string

${param[‘t1']} The value of the request parameter named t1

${header["host"]} The host

Anand & Bhautik

EL API

The javax.servlet.jsp.el API consists of two

classes

• Expression ExpressionEvaluator

Two interfaces

• VariableResolver and FunctionMapper

Two exceptions

• ELException and ELParseException

It works with JSP 2.0 and Tomcat 5 and

above

Anand & Bhautik