Java server pages

Unit 4
Lecture No. 25, 26 and 27
Introduction to Java Server Pages
JavaServer Pages (JSP) is a technology for developing web pages that support dynamic content which
helps developers insert java code in HTML pages by making use of special JSP tags, most of which start
with <% and end with %>.
A JavaServer Pages component is a type of Java servlet that is designed to fulfill the role of a user
interface for a Java web application. Web developers write JSPs as text files that combine HTML or
XHTML code, XML elements, and embedded JSP actions and commands.
Using JSP, you can collect input from users through web page forms, present records from a database or
another source, and create web pages dynamically.
JSP tags can be used for a variety of purposes, such as retrieving information from a database or
registering user preferences, accessing JavaBeans components, passing control between pages and
sharing information between requests, pages etc.
Why Use JSP?
JavaServer Pages often serve the same purpose as programs implemented using the Common
Gateway Interface (CGI). But JSP offer several advantages in comparison with the CGI.
 Performance is significantly better because JSP allows embedding Dynamic Elements in HTML
Pages itself instead of having a separate CGI files.
 JSP are always compiled before it's processed by the server unlike CGI/Perl which requires the
server to load an interpreter and the target script each time the page is requested.
 JavaServer Pages are built on top of the Java Servlets API, so like Servlets, JSP also has
access to all the powerful Enterprise Java APIs, including JDBC, JNDI, EJB, JAXP etc.
 JSP pages can be used in combination with servlets that handle the business logic, the model
supported by Java servlet template engines.
Finally, JSP is an integral part of Java EE, a complete platform for enterprise class applications.
This means that JSP can play a part in the simplest applications to the most complex and
demanding.
Advantages of JSP:
Following is the list of other advantages of using JSP over other technologies:
 vs. Active Server Pages (ASP): The advantages of JSP are twofold. First, the dynamic part is
written in Java, not Visual Basic or other MS specific language, so it is more powerful and easier
to use. Second, it is portable to other operating systems and non-Microsoft Web servers.
 vs. Pure Servlets: It is more convenient to write (and to modify!) regular HTML than to have
plenty of println statements that generate the HTML.
 vs. Server-Side Includes (SSI): SSI is really only intended for simple inclusions, not for "real"
programs that use form data, make database connections, and the like.
 vs. JavaScript: JavaScript can generate HTML dynamically on the client but can hardly interact
with the web server to perform complex tasks like database access and image processing etc.
 vs. Static HTML: Regular HTML, of course, cannot contain dynamic information.

JSP - Architecture
The web server needs a JSP engine ie. container to process JSP pages. The JSP container is
responsible for intercepting requests for JSP pages. This tutorial makes use of Apache which has built-in
JSP container to support JSP pages development.
A JSP container works with the Web server to provide the runtime environment and other services a JSP
needs. It knows how to understand the special elements that are part of JSPs.
Following diagram shows the position of JSP container and JSP files in a Web Application.
JSP Processing:
The following steps explain how the web server creates the web page using JSP:
 As with a normal page, your browser sends an HTTP request to the web server.
 The web server recognizes that the HTTP request is for a JSP page and forwards it to a JSP
engine. This is done by using the URL or JSP page which ends with .jsp instead of .html.
 The JSP engine loads the JSP page from disk and converts it into a servlet content. This
conversion is very simple in which all template text is converted to println( ) statements and all
JSP elements are converted to Java code that implements the corresponding dynamic behavior
of the page.

 The JSP engine compiles the servlet into an executable class and forwards the original request
to a servlet engine.
 A part of the web server called the servlet engine loads the Servlet class and executes it. During
execution, the servlet produces an output in HTML format, which the servlet engine passes to
the web server inside an HTTP response.
 The web server forwards the HTTP response to your browser in terms of static HTML content.
 Finally web browser handles the dynamically generated HTML page inside the HTTP response
exactly as if it were a static page.
JSP - Life Cycle
The key to understanding the low-level functionality of JSP is to understand the simple life cycle
they follow.
A JSP life cycle can be defined as the entire process from its creation till the destruction which
is similar to a servlet life cycle with an additional step which is required to compile a JSP into
servlet.
The following are the paths followed by a JSP
 Compilation
 Initialization
 Execution
 Cleanup
The four major phases of JSP life cycle are very similar to Servlet Life Cycle and they are as
follows:

JSP Compilation:
When a browser asks for a JSP, the JSP engine first checks to see whether it needs to compile
the page. If the page has never been compiled, or if the JSP has been modified since it was last
compiled, the JSP engine compiles the page.
The compilation process involves three steps:
 Parsing the JSP.
 Turning the JSP into a servlet.
 Compiling the servlet.
JSP Initialization:
When a container loads a JSP it invokes the jspInit() method before servicing any requests. If you need to
perform JSP-specific initialization, override the jspInit() method:
public void jspInit(){
// Initialization code...
}
Typically initialization is performed only once and as with the servlet init method, you generally initialize
database connections, open files, and create lookup tables in the jspInit method.
JSP Execution:
This phase of the JSP life cycle represents all interactions with requests until the JSP is destroyed.
Whenever a browser requests a JSP and the page has been loaded and initialized, the JSP engine
invokes the _jspService() method in the JSP.
The _jspService() method takes an HttpServletRequest and an HttpServletResponse as its parameters
as follows:
void _jspService(HttpServletRequest request,
HttpServletResponse response)
{
// Service handling code...
}
The _jspService() method of a JSP is invoked once per a request and is responsible for generating the
response for that request and this method is also responsible for generating responses to all seven of the
HTTP methods ie. GET, POST, DELETE etc.
JSP Cleanup:
The destruction phase of the JSP life cycle represents when a JSP is being removed from use by a
container.
The jspDestroy() method is the JSP equivalent of the destroy method for servlets. Override jspDestroy
when you need to perform any cleanup, such as releasing database connections or closing open files.
The jspDestroy() method has the following form:
public void jspDestroy()
{

// Your cleanup code goes here.
}
Lecture No. 28
JSP – Application Design
The Scriptlet:
A scriptlet can contain any number of JAVA language statements, variable or method
declarations, or expressions that are valid in the page scripting language.
Following is the syntax of Scriptlet:
<% code fragment %>
You can write XML equivalent of the above syntax as follows:
<jsp:scriptlet>
code fragment
</jsp:scriptlet>
Any text, HTML tags, or JSP elements you write must be outside the scriptlet. Following is the simple and first
example for JSP:
<html>
<head><title>Hello World</title></head>
<body>
Hello World!<br/>
<%
out.println("Your IP address is " + request.getRemoteAddr());
%>
</body>
</html>
JSP Declarations:
A declaration declares one or more variables or methods that you can use in Java code later in the JSP file. You
must declare the variable or method before you use it in the JSP file.
Following is the syntax of JSP Declarations:
<%! declaration; [ declaration; ]+ ... %>
<jsp:declaration>
code fragment
</jsp:declaration>
Following is the simple example for JSP Declarations:
<%! int i = 0; %>
<%! int a, b, c; %>
<%! Circle a = new Circle(2.0); %>
JSP Expression:
A JSP expression element contains a scripting language expression that is evaluated, converted to a String, and
inserted where the expression appears in the JSP file.

Because the value of an expression is converted to a String, you can use an expression within a line of text, whether
or not it is tagged with HTML, in a JSP file.
The expression element can contain any expression that is valid according to the Java Language Specification but
you cannot use a semicolon to end an expression.
Following is the syntax of JSP Expression:
<%= expression %>
<jsp:expression>
expression
</jsp:expression>
Following is the simple example for JSP Expression:
<html>
<head><title>A Comment Test</title></head>
<body>
<p>
Today's date: <%= (new java.util.Date()).toLocaleString()%>
</p>
</body>
</html>
This would generate following result:
Today's date: 11-Sep-2010 21:24:25
JSP Comments:
JSP comment marks text or statements that the JSP container should ignore. A JSP comment is useful when you
want to hide or "comment out" part of your JSP page.
Following is the syntax of JSP comments:
<%-- This is JSP comment --%>
Following is the simple example for JSP Comments:
<html>
<head><title>A Comment Test</title></head>
<body>
<h2>A Test of Comments</h2>
<%-- This comment will not be visible in the page source --%>
</body>
</html>
This would generate following result:
A Test of Comments
There are a small number of special constructs you can use in various cases to insert comments or characters that
would otherwise be treated specially. Here's a summary:
Syntax Purpose

<%-- comment --%> A JSP comment.Ignored by the JSP engine.
 An HTML comment.Ignored by the browser.
<% Represents static <% literal.
%> Represents static %> literal.
' A single quote in an attribute that uses single quotes.
" A double quote in an attribute that uses double quotes.
JSP Directives:
A JSP directive affects the overall structure of the servlet class. It usually has the following form:
<%@ directive attribute="value" %>
There are three types of directive tag:
Directive Description
<%@ page ... %>
Defines page-dependentattributes,such as scripting language,error
page,and buffering requirements.
<%@ include ... %> Includes a file during the translation phase.
<%@ taglib ... %> Declares a tag library, containing custom actions,used in the page
We would explain JSP directive in separate chapter JSP - Directives
JSP Actions:
JSP actions use constructs in XML syntax to control the behavior of the servlet engine. You can dynamically insert a
file, reuse JavaBeans components, forward the user to another page, or generate HTML for the Java plugin.
There is only one syntax for the Action element, as it conforms to the XML standard:
<jsp:action_name attribute="value" />
Action elements are basically predefined functions and there are following JSP actions available:
Syntax Purpose
jsp:include Includes a file at the time the page is requested
jsp:include Includes a file at the time the page is requested
jsp:useBean Finds or instantiates a JavaBean
jsp:setProperty Sets the property of a JavaBean
jsp:getProperty Inserts the property of a JavaBean into the output
jsp:forward Forwards the requester to a new page
jsp:plugin
Generates browser-specific code thatmakes an OBJECT or EMBED tag
for the Java plugin
jsp:element Defines XML elements dynamically.
jsp:attribute Defines dynamicallydefined XML element's attribute.
jsp:body Defines dynamicallydefined XML element's body.
jsp:text Use to write template text in JSP pages and documents.
We would explain JSP actions in separate chapter JSP - Actions
JSP Implicit Objects:

JSP supports nine automatically defined variables, which are also called implicit objects. These variables are:
Objects Description
request This is the HttpServletRequest objectassociated with the request.
response
This is the HttpServletResponse objectassociated with the response to
the client.
out This is the PrintWriter object used to send outputto the client.
session This is the HttpSession object associated with the request.
application This is the ServletContext objectassociated with application context.
config This is the ServletConfig object associated with the page.
pageContext
This encapsulates use ofserver-specific features like higher
performance JspWriters.
page
This is simplya synonym for this, and is used to call the methods defined
by the translated servletclass.
Exception
The Exception objectallows the exception data to be accessed by
designated JSP.
We would explain JSP Implicit Objects in separate chapter JSP - Implicit Objects.
Control-Flow Statements:
JSP provides full power of Java to be embedded in your web application. You can use all the APIs and building
blocks of Java in your JSP programming including decision making statements, loops etc.
Decision-Making Statements:
The if...else block starts out like an ordinary Scriptlet, but the Scriptlet is closed at each line with HTML text included
between Scriptlet tags.
<%! int day = 3; %>
<html>
<head><title>IF...ELSE Example</title></head>
<body>
<% if (day == 1 | day == 7) { %>
<p> Today is weekend</p>
<% } else { %>
<p> Today is not weekend</p>
<% } %>
</body>
</html>
This would produce following result:
Today is not weekend
Now look at the following switch...case block which has been written a bit differentlty using out.println()and inside
Scriptletas:
<%! int day = 3; %>
<html>
<head><title>SWITCH...CASE Example</title></head>
<body>
<%
switch(day) {
case 0:
out.println("It's Sunday.");
break;
case 1:
out.println("It's Monday.");
break;
case 2:
out.println("It's Tuesday.");

break;
case 3:
out.println("It's Wednesday.");
break;
case 4:
out.println("It's Thursday.");
break;
case 5:
out.println("It's Friday.");
break;
default:
out.println("It's Saturday.");
}
%>
</body>
</html>
It's Wednesday.
Loop Statements:
You can also use three basic types of looping blocks in Java: for, while,and do…while blocks in your JSP
programming.
Let us look at the following for loop example:
<%! int fontSize; %>
<html>
<head><title>FOR LOOP Example</title></head>
<body>
<%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
<font color="green" size="<%= fontSize %>">
JSP Tutorial
</font><br />
<%}%>
</body>
</html>
JSP Tutorial
JSP Tutorial
JSP Tutorial
Above example can be written using while loop as follows:
<%! int fontSize; %>
<html>
<head><title>WHILE LOOP Example</title></head>
<body>
<%while ( fontSize <= 3){ %>
<font color="green" size="<%= fontSize %>">
JSP Tutorial
</font><br />
<%fontSize++;%>
<%}%>
</body>
</html>
This would also produce following result:
JSP Tutorial
JSP Tutorial
JSP Tutorial

JSP Operators:
JSP supports all the logical and arithmetic operators supported byJava. Following table give a listof all the operators
with the highest precedence appear at the top of the table, those with the lowest appear at the bottom.
Within an expression, higher precedence operators will be evaluated first.
Category Operator Associativity
Postfix () [] . (dot operator) Left to right
Unary ++ - - ! ~ Rightto left
Multiplicative * / % Left to right
Additive + - Left to right
Shift >> >>> << Left to right
Relational > >= < <= Left to right
Equality == != Left to right
Bitwise AND & Left to right
Bitwise XOR ^ Left to right
Bitwise OR | Left to right
Logical AND && Left to right
Logical OR || Left to right
Conditional ?: Rightto left
Assignment = += -= *= /= %= >>= <<= &= ^= |= Rightto left
Comma , Left to right
JSP Literals:
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
JSP - Directives
JSP directives provide directions and instructions to the container, telling it how to handle certain aspects of JSP
processing.
A JSP directive affects the overall structure of the servlet class. It usually has the following form:
<%@ directive attribute="value" %>
Directives can have a number of attributes which you can list down as key-value pairs and separated by commas.
The blanks between the @ symbol and the directive name, and between the last attribute and the closing %>, are
optional.
There are three types of directive tag:
Directive Description
<%@ page ... %> Defines page-dependentattributes,such as scripting language,error

page,and buffering requirements.
<%@ include ... %> Includes a file during the translation phase.
<%@ taglib ... %> Declares a tag library, containing custom actions,used in the page
The page Directive:
The page directive is used to provide instructions to the container that pertain to the currentJSP page.You may code
page directives anywhere in your JSP page. By convention, page directives are coded at the top of the JSP page.
Following is the basic syntax of page directive:
<%@ page attribute="value" %>
<jsp:directive.page attribute="value" />
Attributes:
Following is the list of attributes associated with page directive:
Attribute Purpose
buffer Specifies a buffering model for the outputstream.
autoFlush Controls the behavior of the servlet outputbuffer.
contentType Defines the character encoding scheme.
errorPage
Defines the URL of another JSP that reports on Java unchecked runtime
exceptions.
isErrorPage
Indicates if this JSP page is a URL specified byanother JSP page's
errorPage attribute.
extends Specifies a superclass thatthe generated servletmustextend
import
Specifies a listof packages or classes for use in the JSP as the Java
importstatementdoes for Java classes.
info
Defines a string that can be accessed with the servlet's getServletInfo()
method.
isThreadSafe Defines the threading model for the generated servlet.
language Defines the programming language used in the JSP page.
session Specifies whether or not the JSP page participates in HTTP sessions
isELIgnored
Specifies whether or not EL expression within the JSP page will be
ignored.
isScriptingEnabled Determines ifscripting elements are allowed for use.
Check more detail related to all the above attributes at Page Directive.
The include Directive:
The include directive is used to includes a file during the translation phase.This directive tells the container to merge
the content of other external files with the current JSP during the translation phase. You may code include directives
anywhere in your JSP page.
The general usage form of this directive is as follows:
<%@ include file="relative url" >
The filename in the include directive is actually a relative URL. If you just specify a filename with no associated path,
the JSP compiler assumes that the file is in the same directory as your JSP.

<jsp:directive.include file="relative url" />
Check more detail related to include directive at Include Directive.
The taglib Directive:
The JavaServer Pages API allows you to define custom JSP tags that look like HTML or XML tags and a tag library is
a set of user-defined tags that implement custom behavior.
The taglib directive declares that your JSP page uses a set of custom tags, identifies the location of the library, and
provides a means for identifying the custom tags in your JSP page.
The taglib directive follows the following syntax:
<%@ taglib uri="uri" prefix="prefixOfTag" >
Where the uri attribute value resolves to a location the container understands and the prefix attribute informs a
container what bits of markup are custom actions.
<jsp:directive.taglib uri="uri" prefix="prefixOfTag" />
Check more detail related to taglib directive at Taglib Directive.
JSP - Client Request
When a browser requests for a web page,it sends lot of information to the web server which can not be read directly
because this information travel as a part of header of HTTP request. You can check HTTP Protocol for more
information on this.
Following is the important header information which comes from browser side and you would use very frequently in
web programming:
Header Description
Accept
This header specifies the MIME types that the browser or other clients
can handle.Values of image/png or image/jpeg are the two most
common possibilities.
Accept-Charset
This header specifies the character sets the browser can use to display
the information.For example ISO-8859-1.
Accept-Encoding
This header specifies the types of encodings thatthe browser knows how
to handle.Values of gzip or compress are the two mostcommon
possibilities.
Accept-Language
This header specifies the client's preferred languages in case the servlet
can produce results in more than one language.For example en, en-us,
ru, etc.
Authorization
This header is used by clients to identify themselves when accessing
password-protected Web pages.
Connection
This header indicates whether the clientcan handle persistentHTTP
connections.Persistentconnections permitthe clientor other browser to
retrieve multiple files with a single request.A value ofKeep-Alive means
that persistentconnections should be used

Content-Length
This header is applicable onlyto POST requests and gives the size of the
POST data in bytes.
Cookie
This header returns cookies to servers that previouslysentthem to the
browser.
Host This header specifies the hostand portas given in the original URL.
If-Modified-Since
This header indicates thatthe clientwants the page only if it has been
changed after the specified date.The server sends a code,304 which
means Not Modified header if no newer resultis available.
If-Unmodified-Since
This header is the reverse of If-Modified-Since; it specifies thatthe
operation should succeed onlyif the documentis older than the specified
date.
Referer
This header indicates the URL of the referring Web page. For example,if
you are at Web page 1 and click on a link to Web page 2, the URL of Web
page 1 is included in the Referer header when the browser requests Web
page 2.
User-Agent
This header identifies the browser or other client making the requestand
can be used to return different contentto differenttypes of browsers.
The HttpServletRequest Object:
The request object is an instance of a javax.servlet.http.HttpServletRequest object. Each time a client requests a
page the JSP engine creates a new object to represent that request.
The request object provides methods to get HTTP header information including form data, cookies, HTTP methods
etc.
There are following importantmethods which can be used to read HTTP header in your JSP program.These method
are available with HttpServletRequest object which represents client request to webserver.
S.N. Method & Description
1
Cookie[] getCookies()
Returns an array containing all of the Cookie objects the clientsentwith this request.
2
Enumeration getAttributeNames()
Returns an Enumeration containing the names ofthe attributes available to this request.
3
Enumeration getHeaderNames()
Returns an enumeration ofall the header names this requestcontains.
4
Enumeration getParameterNames()
Returns an Enumeration ofString objects containing the names ofthe parameters contained in
this request.
5
HttpSession getSession()
Returns the current session associated with this request,or if the requestdoes nothave a
session,creates one.

6
HttpSession getSession(boolean create)
Returns the current HttpSession associated with this requestor,if if there is no current session
and create is true, returns a new session.
7
Locale getLocale()
Returns the preferred Locale that the clientwill accept contentin, based on the Accept-Language
header
8
Object getAttribute(String name)
Returns the value of the named attribute as an Object, or null if no attribute of the given name
exists.
9
ServletInputStream getInputStream()
Retrieves the body of the requestas binarydata using a ServletInputStream.
10
String getAuthType()
Returns the name of the authentication scheme used to protectthe servlet, for example,"BASIC"
or "SSL," or null if the JSP was notprotected
11
String getCharacterEncoding()
Returns the name of the character encoding used in the body of this request.
12
String getContentType()
Returns the MIME type of the body of the request,or null if the type is not known.
13
String getContextPath()
Returns the portion of the requestURIthat indicates the context of the request.
14
String getHeader(String name)
Returns the value of the specified requestheader as a String.
15
String getMethod()
Returns the name of the HTTP method with which this requestwas made,for example,GET,
POST, or PUT.
16
String getParameter(Stringname)
Returns the value of a requestparameter as a String,or null if the parameter does not exist.
17
String getPathInfo()
Returns any extra path information associated with the URL the client sentwhen it made this
request.
18
String getProtocol()
Returns the name and version of the protocol the request.
19
String getQueryString()
Returns the query string that is contained in the requestURL after the path.
20
String getRemoteAddr()
Returns the Internet Protocol (IP) address ofthe clientthat sentthe request.
21
String getRemoteHost()

Returns the fully qualified name ofthe clientthat sentthe request.
22
String getRemoteUser()
Returns the login of the user making this request,ifthe user has been authenticated,or null if the
user has notbeen authenticated.
23
String getRequestURI()
Returns the part of this request's URL from the protocol name up to the query string in the first
line of the HTTP request.
24
String getRequestedSessionId()
Returns the session ID specified by the client.
25
String getServletPath()
Returns the part of this request's URL thatcalls the JSP.
26
String[] getParameterValues(Stringname)
Returns an array of String objects containing all ofthe values the given requestparameter has,
or null if the parameter does notexist.
27
boolean isSecure()
Returns a boolean indicating whether this requestwas made using a secure channel,such as
HTTPS.
28
int getContentLength()
Returns the length, in bytes, of the requestbody and made available by the input stream,or -1 if
the length is not known.
29
int getIntHeader(String name)
Returns the value of the specified requestheader as an int.
30
int getServerPort()
Returns the port number on which this requestwas received.
HTTP Header Request Example:
Following is the example which uses getHeaderNames() method of HttpServletRequest to read the HTTP header
infromation. This method returns an Enumeration that contains the header information associated with the current
HTTP request.
Once we have an Enumeration, we can loop down the Enumeration in the standard manner,
usinghasMoreElements() method to determine when to stop and using nextElement() method to get each parameter
name.
<%@ page import="java.io.*,java.util.*" %>
<html>
<head>
<title>HTTP Header Request Example</title>
</head>
<body>
<center>
<h2>HTTP Header Request Example</h2>
<table width="100%" border="1" align="center">
<tr bgcolor="#949494">
<th>Header Name</th><th>Header Value(s)</th>
</tr>
<%
Enumeration headerNames = request.getHeaderNames();
while(headerNames.hasMoreElements()) {
String paramName = (String)headerNames.nextElement();
out.print("<tr><td>" + paramName + "</td>n");

String paramValue = request.getHeader(paramName);
out.println("<td> " + paramValue + "</td></tr>n");
}
%>
</table>
</center>
</body>
</html>
Now put the above code in main.jsp and try to access it. This would produce result something as follows:
HTTP Header Request Example
Header Name Header Value(s)
accept */*
accept-language en-us
user-agent
Mozilla/4.0 (compatible;MSIE 7.0; Windows NT 5.1; Trident/4.0; InfoPath.2; MS-
RTC LM 8)
accept-encoding gzip, deflate
host localhost:8080
connection Keep-Alive
cache-control no-cache
To become more comfortable with other methods you can try few more above listed methods in the same fashion.
JSP - Form Processing
You must have come across many situations when you need to pass some information from your browser to web
server and ultimately to your backend program. The browser uses two methods to pass this information to web
server. These methods are GET Method and POST Method.
GET method:
The GET method sends the encoded user information appended to the page request. The page and the encoded
information are separated by the ? character as follows:
http://www.test.com/hello?key1=value1&key2=value2
The GET method is the default method to pass information from browser to web server and it produces a long string
that appears in your browser's Location:box. Never use the GET method if you have password or other sensitive
information to pass to the server.
The GET method has size limitation: only 1024 characters can be in a request string.
This information is passed using QUERY_STRING header and will be accessible through QUERY_STRING
environment variable which can be handled using getQueryString() and getParameter() methods of request object.
POST method:
A generally more reliable method of passing information to a backend program is the POST method.

This method packages the information in exactly the same way as GET methods, but instead of sending it as a text
string after a ? in the URL it sends it as a separate message. This message comes to the backend program in the
form of the standard input which you can parse and use for your processing.
JSP handles this type of requests using getParameter() method to read simple parameters and getInputStream()
method to read binary data stream coming from the client.
Reading Form Data using JSP
JSP handles form data parsing automatically using the following methods depending on the situation:
 getParameter(): You call request.getParameter() method to get the value of a form parameter.
 getParameterValues(): Call this method if the parameter appears more than once and returns multiple values, for
example checkbox.
 getParameterNames(): Call this method if you want a complete list of all parameters in the current request.
 getInputStream(): Call this method to read binary data stream coming from the client.
GET Method Example Using URL:
Here is a simple URL which will pass two values to HelloForm program using GET method.
http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI
Below is main.jsp JSP program to handle input given by web browser. We are going to usegetParameter() method
which makes it very easy to access passed information:
<html>
<head>
<title>Using GET Method to Read Form Data</title>
</head>
<body>
<center>
<h1>Using GET Method to Read Form Data</h1>
<ul>
<li><p><b>First Name:</b>
<%= request.getParameter("first_name")%>
</p></li>
<li><p><b>Last Name:</b>
<%= request.getParameter("last_name")%>
</p></li>
</ul>
</body>
</html>
Now type http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI in your browser's Location:box. This
would generate following result:
Using GET Method to Read Form Data
 First Name: ZARA
 Last Name: ALI
GET Method Example Using Form:
Here is a simple example which passes two values using HTML FORM and submitbutton.We are going to use same
JSP main.jsp to handle this input.
<html>
<body>
<form action="main.jsp" method="GET">
First Name: <input type="text" name="first_name">
<br />
Last Name: <input type="text" name="last_name" />
<input type="submit" value="Submit" />
</form>
</body>
</html>

Keep this HTML in a file Hello.htm and put it in <Tomcat-installation-directory>/webapps/ROOT directory. When you
would access http://localhost:8080/Hello.htm, here is the actual output of the above form.
First Name:
LastName:
Try to enter First Name and Last Name and then click submit button to see the result on your local machine where
tomcat is running. Based on the input provided, it will generate similar result as mentioned in the above example.
POST Method Example Using Form:
Let us do little modification in the above JSP to handle GET as well as POST methods. Below is main.jsp JSP
program to handle input given by web browser using GET or POST methods.
Infact there is no change in above JSP because only way of passing parameters is changed and no binary data is
being passed to the JSP program.File handling related concepts would be explained in separate chapter where we
need to read binary data stream.
<html>
<head>
<title>Using GET and POST Method to Read Form Data</title>
</head>
<body>
<center>
<h1>Using GET Method to Read Form Data</h1>
<ul>
<li><p><b>First Name:</b>
<%= request.getParameter("first_name")%>
</p></li>
<li><p><b>Last Name:</b>
<%= request.getParameter("last_name")%>
</p></li>
</ul>
</body>
</html>
Following is the content of Hello.htm file:
<html>
<body>
<form action="main.jsp" method="POST">
First Name: <input type="text" name="first_name">
<br />
Last Name: <input type="text" name="last_name" />
<input type="submit" value="Submit" />
</form>
</body>
</html>
Now let us keep main.jsp and hello.htm in <Tomcat-installation-directory>/webapps/ROOT directory. When you would
access http://localhost:8080/Hello.htm, below is the actual output of the above form.
First Name:
LastName:
Try to enter First and LastName and then click submitbutton to see the resulton your local machine where tomcat is
running.
Based on the input provided, it would generate similar result as mentioned in the above examples.
Passing Checkbox Data to JSP Program

Checkboxes are used when more than one option is required to be selected.
Here is example HTML code, CheckBox.htm, for a form with two checkboxes
<html>
<body>
<form action="main.jsp" method="POST" target="_blank">
<input type="checkbox" name="maths" checked="checked" /> Maths
<input type="checkbox" name="physics" /> Physics
<input type="checkbox" name="chemistry" checked="checked" />
Chemistry
<input type="submit" value="Select Subject" />
</form>
</body>
</html>
The result of this code is the following form
Maths Physics Chemistry
Below is main.jsp JSP program to handle input given by web browser for checkbox button.
<html>
<head>
<title>Reading Checkbox Data</title>
</head>
<body>
<center>
<h1>Reading Checkbox Data</h1>
<ul>
<li><p><b>Maths Flag:</b>
<%= request.getParameter("maths")%>
</p></li>
<li><p><b>Physics Flag:</b>
<%= request.getParameter("physics")%>
</p></li>
<li><p><b>Chemistry Flag:</b>
<%= request.getParameter("chemistry")%>
</p></li>
</ul>
</body>
</html>
For the above example, it would display following result:
Reading Checkbox Data
 Maths Flag : : on
 Physics Flag: : null
 Chemistry Flag: : on
Reading All Form Parameters:
Following is the generic example which uses getParameterNames() method of HttpServletRequest to read all the
available form parameters.This method returns an Enumeration thatcontains the parameter names in an unspecified
order.
Once we have an Enumeration, we can loop down the Enumeration in the standard manner,
usinghasMoreElements() method to determine when to stop and using nextElement() method to get each parameter
name.
<html>
<head>
<title>HTTP Header Request Example</title>
</head>

<body>
<center>
<h2>HTTP Header Request Example</h2>
<table width="100%" border="1" align="center">
<th>Param Name</th><th>Param Value(s)</th>
</tr>
<%
Enumeration paramNames = request.getParameterNames();
while(paramNames.hasMoreElements()) {
String paramName = (String)paramNames.nextElement();
out.print("<tr><td>" + paramName + "</td>n");
String paramValue = request.getHeader(paramName);
out.println("<td> " + paramValue + "</td></tr>n");
}
%>
</table>
</center>
</body>
</html>
Following is the content of Hello.htm:
<html>
<body>
<form action="main.jsp" method="POST" target="_blank">
<input type="checkbox" name="maths" checked="checked" /> Maths
<input type="checkbox" name="physics" /> Physics
<input type="checkbox" name="chemistry" checked="checked" /> Chem
<input type="submit" value="Select Subject" />
</form>
</body>
</html>
Now try calling JSP using above Hello.htm, this would generate a result something like as below based on the
provided input:
Reading All Form Parameters
Param Name Param Value(s)
maths on
chemistry on
You can try above JSP to read any other form's data which is having other objects like text box, radio button or drop
down box etc.
JSP - Session Tracking
HTTP is a "stateless" protocol which means each time a client retrieves a Web page, the client opens a separate
connection to the Web server and the server automatically does not keep any record of previous client request.
Still there are following three ways to maintain session between web client and web server:
Cookies:
A webserver can assign a unique session ID as a cookie to each web client and for subsequent requests from the
client they can be recognized using the received cookie.
This may not be an effective way because manytime browser does notsupporta cookie, so I would not recommend
to use this procedure to maintain the sessions.

Hidden Form Fields:
A web server can send a hidden HTML form field along with a unique session ID as follows:
<input type="hidden" name="sessionid" value="12345">
This entry means that, when the form is submitted, the specified name and value are automatically included in the
GET or POST data. Each time when web browser sends request back, then session_id value can be used to keep
the track of different web browsers.
This could be an effective way of keeping track of the session but clicking on a regular (<A HREF...>) hypertext link
does not result in a form submission, so hidden form fields also cannot support general session tracking.
URL Rewriting:
You can append some extra data on the end of each URL that identifies the session, and the server can associate
that session identifier with data it has stored about that session.
For example, with http://tutorialspoint.com/file.htm;sessionid=12345, the session identifier is attached as
sessionid=12345 which can be accessed at the web server to identify the client.
URL rewriting is a better way to maintain sessions and works for the browsers when they don't support cookies but
here drawback is that you would have generate every URL dynamicallyto assign a session ID though page is simple
static HTML page.
The session Object:
Apart from the above mentioned three ways, JSP makes use of servlet provided HttpSes sion Interface which
provides a way to identify a user across more than one page request or visit to a Web site and to store information
about that user.
By default, JSPs have session tracking enabled and a new HttpSession object is instantiated for each n ew client
automatically.Disabling session tracking requires explicitlyturning it off by setting the page directive session attribute
to false as follows:
<%@ page session="false" %>
The JSP engine exposes the HttpSession object to the JSP author through the implicit session object.
Since session object is already provided to the JSP programmer,the programmer can immediatelybegin storing and
retrieving data from the object without any initialization or getSession().
Here is a summary of important methods available through session object:
S.N. Method & Description
1
public Object getAttribute(String name)
This method returns the objectbound with the specified name in this session,or null if no object
is bound under the name.
2
public Enumeration getAttributeNames()
This method returns an Enumeration ofString objects containing the names ofall the objects
bound to this session.
3
public long getCreationTime()
This method returns the time when this session was created, measured in milliseconds since
midnightJanuary1, 1970 GMT.
4
public String getId()

This method returns a string containing the unique identifier assigned to this session.
5
public long getLastAccessedTime()
This method returns the lasttime the client senta requestassociated with this session,as the
number ofmilliseconds since midnightJanuary1, 1970 GMT.
6
public int getMaxInactiveInterval()
This method returns the maximum time interval,in seconds,thatthe servlet container will keep
this session open between clientaccesses.
7
public void invalidate()
This method invalidates this session and unbinds anyobjects bound to it.
8
public boolean isNew(
This method returns true if the client does notyet know aboutthe session or if the client chooses
not to join the session.
9
public void removeAttribute(String name)
This method removes the objectbound with the specified name from this session.
10
public void setAttribute(String name, Object value)
This method binds an objectto this session,using the name specified.
11
public void setMaxInactiveInterval(int interval)
This method specifies the time,in seconds,between clientrequests before the servletcontainer
will invalidate this session.
Session Tracking Example:
This example describes how to use the HttpSession objectto find out the creation time and the last-accessed time for
a session. We would associate a new session with the request if one does not already exist.
<%
// Get session creation time.
Date createTime = new Date(session.getCreationTime());
// Get last access time of this web page.
Date lastAccessTime = new Date(session.getLastAccessedTime());
String title = "Welcome Back to my website";
Integer visitCount = new Integer(0);
String visitCountKey = new String("visitCount");
String userIDKey = new String("userID");
String userID = new String("ABCD");
// Check if this is new comer on your web page.
if (session.isNew()){
title = "Welcome to my website";
session.setAttribute(userIDKey, userID);

session.setAttribute(visitCountKey, visitCount);
}
visitCount = (Integer)session.getAttribute(visitCountKey);
visitCount = visitCount + 1;
userID = (String)session.getAttribute(userIDKey);
session.setAttribute(visitCountKey, visitCount);
%>
<html>
<head>
<title>Session Tracking</title>
</head>
<body>
<center>
<h1>Session Tracking</h1>
</center>
<table border="1" align="center">
<th>Session info</th>
<th>Value</th>
</tr>
<tr>
<td>id</td>
<td><% out.print( session.getId()); %></td>
</tr>
<tr>
<td>Creation Time</td>
<td><% out.print(createTime); %></td>
</tr>
<tr>
<td>Time of Last Access</td>
<td><% out.print(lastAccessTime); %></td>
</tr>
<tr>
<td>User ID</td>
<td><% out.print(userID); %></td>
</tr>
<tr>
<td>Number of visits</td>
<td><% out.print(visitCount); %></td>
</tr>
</table>

</body>
</html>
Now put above code in main.jsp and try to access http://localhost:8080/main.jsp. It would display the following result
when you would run for the first time:
Welcome to my website
Session Infomation
Session info value
id 0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time Tue Jun 08 17:26:40 GMT+04:00 2010
Time of LastAccess Tue Jun 08 17:26:40 GMT+04:00 2010
User ID ABCD
Number ofvisits 0
Now try to run the same JSP for second time, it would display following result.
Welcome Back to my website
Session Infomation
info type value
id 0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time Tue Jun 08 17:26:40 GMT+04:00 2010
Time of LastAccess Tue Jun 08 17:26:40 GMT+04:00 2010
User ID ABCD
Number ofvisits 1
Deleting Session Data:
When you are done with a user's session data, you have several options:
 Remove a particular attribute: You can call public void removeAttribute(String name) method to delete the value
associated with a particular key.
 Delete the whole session: You can call public void invalidate() method to discard an entire session.
 Setting Session timeout: You can call public void setMaxInactiveInterval(intinterval) method to set the timeout for a
session individually.
 Log the user out: The servers that support servlets 2.4, you can call logout to log the client out of the Web server
and invalidate all sessions belonging to all the users.
 web.xml Configuration: If you are using Tomcat, apart from the above mentioned methods, you can configure
session time out in web.xml file as follows.
<session-config>

<session-timeout>15</session-timeout>
</session-config>
The timeout is expressed as minutes, and overrides the default timeout which is 30 minutes in Tomcat.
The getMaxInactiveInterval( ) method in a servlet returns the timeout period for that session in seconds. So if your
session is configured in web.xml for 15 minutes, getMaxInactiveInterval( ) returns 900.
JSP - Page Redirecting
Page redirection is generallyused when a document moves to a new location and we need to send the client to this
new location or may be because of load balancing, or for simple randomization.
The simplest way of redirecting a request to another page is using method sendRedirect() of response object.
Following is the signature of this method:
public void response.sendRedirect(String location)
throws IOException
This method sends back the response to the browser along with the status code and new page location.You can also
use setStatus() and setHeader() methods together to achieve the same redirection:
....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
....
Example:
This example shows how a JSP performs page redirection to an another location:
<html>
<head>
<title>Page Redirection</title>
</head>
<body>
<center>
<h1>Page Redirection</h1>
</center>
<%
// New location to be redirected
String site = new String("http://www.photofuntoos.com");
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
%>
</body>
</html>
Now let us put above code in PageRedirect.jsp and call this JSP using URL http://localhost:8080/PageRedirect.jsp.
This would take you given URL http://www.photofuntoos.com.
JSP - Hits Counter
A hit counter tells you about the number of visits on a particular page of your web site. Usually you attach a hit
counter with your index.jsp page assuming people first land on your home page.
To implementa hit counter you can make use of Application Implicit objectand associated methods getAttribute() and
setAttribute().
This objectis a representation of the JSP page through its entire lifecycle. This object is created when the JSP page
is initialized and will be removed when the JSP page is removed by the jspDestroy() method.
Following is the syntax to set a variable at application level:

application.setAttribute(String Key, Object Value);
You can use above method to set a hit counter variable and to reset the same variable. Following is the method to
read the variable set by previous method:
application.getAttribute(String Key);
Every time a use access your page, you can read current value of hit counter and increase it by one and again set it
for future use.
Example:
This example shows how you can use JSP to count total number of hits on a particular page. If you want to count
total number of hits of your website then you would have to include same code in all the JSP pages.
<html>
<head>
<title>Applcation object in JSP</title>
</head>
<body>
<%
Integer hitsCount =
(Integer)application.getAttribute("hitCounter");
if( hitsCount ==null || hitsCount == 0 ){
/* First visit */
out.println("Welcome to my website!");
hitsCount = 1;
}else{
/* return visit */
out.println("Welcome back to my website!");
hitsCount += 1;
}
application.setAttribute("hitCounter", hitsCount);
%>
<center>
<p>Total number of visits: <%= hitsCount%></p>
</center>
</body>
</html>
Now let us put above code in main.jsp and call this JSP using URL http://localhost:8080/main.jsp. This would display
hit counter value which would increase every time when you refresh the page. You can try to access the page using
different browsers and you will find that hit counter will keep increasing with every hit and would display result
something as follows:
Welcome back to my website!
Total number of visits: 12
Hit Counter Resets:
What about if you re-startyour application ie.web server, this will resetyour application variable and your counter will
reset to zero. To avoid this loss, you can implement your counter in professional way which is as follows:
 Define a database table with a single count, let us say hitcount. Assign a zero value to it.
 With every hit, read the table to get the value of hitcount.
 Increase the value of hitcount by one and update the table with new value.

 Display new value of hitcount as total page hit counts.
 If you want to count hits for all the pages, implement above logic for all the pages.
JSP - Auto Refresh
Consider a webpage which is displaying live game score or stock market status or currency exchange ration. For all
such type of pages, you would need to refresh your web page regularly using refresh or reload butto n with your
browser.
JSP makes this job easyby providing you a mechanism where you can make a webpage in such a way that it would
refresh automatically after a given interval.
The simplest way of refreshing a web page is using method setIntHeader() of response object. Following is the
signature of this method:
public void setIntHeader(String header, int headerValue)
This method sends back header "Refresh"to the browser along with an integer value which indicates time interval in
seconds.
Auto Page Refresh Example:
Following example would use setIntHeader() method to set Refresh header to simulate a digital clock:
<html>
<head>
<title>Auto Refresh Header Example</title>
</head>
<body>
<center>
<h2>Auto Refresh Header Example</h2>
<%
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Get current time
Calendar calendar = new GregorianCalendar();
String am_pm;
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
if(calendar.get(Calendar.AM_PM) == 0)
am_pm = "AM";
else
am_pm = "PM";
String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
out.println("Crrent Time: " + CT + "n");
%>
</center>
</body>
</html>
Now put the above code in main.jsp and try to access it. This would display current system time after every 5
seconds as follows. Just run the JSP and wait to see the result:
Auto Refresh Header Example
Current Time is: 9:44:50 PM
To become more comfortable with other methods you can try few more above listed methods in the same fashion.

Java server pages

More Related Content

What's hot (20)

Viewers also liked (8)

Similar to Java server pages (20)

More from Abhishek Kesharwani (20)

Java server pages