MANGALORE UNIVERSITY

National Education Policy – 2020

[NEP-2020]

STUDY MATERIALS
FOR

VI SEMESTER BCA

ADVANCED JAVA AND J2EE-UNIT-IV

JSP-PART-1
 JSP - OVERVIEW
What is Java Server Pages?
Java Server Pages (JSP) is a technology for developing Web pages that supports
dynamic content. This helps developers insert java code in HTML pages by
making use of special JSP tags, most of which start with <% and end with %>.
A Java Server 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 Webpage 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?

Java Server Pages often serve the same purpose as programs implemented
using the Common Gateway Interface (CGI). But JSP offers several
advantages in comparison with the CGI.
 Performance is significantly better because JSP allows embedding
Dynamic Elements in HTML Pages itself instead of having separate CGI
files.
 JSP are always compiled before they are 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.
 Java Server 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 cannot contain dynamic information.
JSP - Architecture
The web server needs a JSP engine, i.e., a container to process JSP pages. The
JSP container is responsible for intercepting requests for JSP pages. This
material 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, browser (client) 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. This code 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.
 Apart 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. This output is further passed on to the web server by the
servlet engine inside an HTTP response.
 The web server forwards the HTTP response to our browser in terms of
static HTML content.
  Finally, the web browser handles the dynamically-generated HTML page
inside the HTTP response exactly as if it were a static page.
All the above mentioned steps canbe seen in the following diagram:

Typically, the JSP engine checks to see whether a servlet for a JSP file already
exists and whether the modification date on the JSP is older than the servlet. If
the JSP is older than its generated servlet, the JSP container assumes that the
JSP hasn't changed and that the generated servlets till matches the JSP's
contents. This makes the process more efficient than with the other scripting
languages (such as PHP) and therefore faster.
So in a way, a JSP page is really just another way to write a servlet without
having to be a Java programming wiz. Except for the translation phase, a JSP
page is handled exactly like a regular servlet.

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 is defined as the process from its creation till the destruction.
This is similar to a servlet life cycle with an additional step which is required to
compile a JSP into servlet.

Paths Followed By JSP

The following are the paths followed by a JSP
 Compilation
  Initialization
 Execution
 Cleanup

The four major phases of a JSP life cycle are very similar to the Servlet Life
Cycle. The four phases have been described below:

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 in to a servlet.
 Compiling the servlet.

JSP Initialization
When a container loads a JSP it invokes the jspInit() method before servicing
any requests. If we need to perform JSP-specific initialization, override the
jspInit() method:

Public void jspInit(){

//Initializationcode...
}

Typically, initialization is performed only once and as with the servlet init
method, we 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)

{
//Servicehandlingcode...
}

The _jspService() method of a JSP is invoked on request basis. This 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, i.e.,
GET, POST, DELETE, etc.

JSP Cleanup
The destruction phase of the JSP lifecycle 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()
{
//Yourcleanupcodegoeshere.
}

P─SYNTAX
JSP Syntax:
Let us understand the basic use of simple syntax (i.e., elements) involved with
JSP development.
Elements of JSP
The elements of JSP have been described below:

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 %>

We can write the XML equivalent of the above syntax as follows:

<jsp:scriptlet>

Code fragment
</jsp:scriptlet>

Any text, HTML tags, or JSP elements we write must be outside the scriptlet.
Following is the simple and first example for JSP:
 <html>
<head><title>HelloWorld</title></head>
<body>
HelloWorld!<br/>
<%
out.println("Your IP address is"+request.getRemoteAddr());
%>
</body>
</html>

Let us keep the above code in JSP file hello.jsp and put this file inC:\apache-
tomcat- 7.0.2\webapps\ROOT directory. Browse through the same using URL
http://localhost:8080/hello.jsp. This would generate the following result:

JSP Declarations
A declaration declares one or more variables or methods that we 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 for JSP Declarations:

<%! declaration; [declaration;]+... %>

You can write the XML equivalent of the above syntax as follows:
 Following is an 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 %>

You can write the XML equivalent of the above syntax as follows:

<jsp:expression>
expression
</jsp:expression>

Following example shows a JSP Expression:

<html>
<head><title>A Comment Test</title></head>
<body>
<p>
Today'sdate:<%= (new java.util.Date()).toLocaleString()%>
</p>
</body>
</html>
 The above code will generate the following result:

JSP Comments
JSP comment marks the text or the statements that the JSP container should
ignore. A JSP comment is useful when you want to hide or "comment out", a
part of your JSP page.
Following is the syntax of the JSP comments:

<%-- This is JSP comment-- %>

Following example shows the 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>

The above code will generate the following result:

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.

 <!--comment--> 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 quotein 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

Defines page-dependent attributes, such

<%@ page... %>
as scripting language, error page and buffering
requirements.
<%@ include... %> Includes a file during the translation phase.

Declares a tag library, containing custom actions,

<%@ taglib... %>
used in the page

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. Following table lists out the
available JSP Actions:

Syntax Purpose

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 that makes an

OBJECT or EMBED tag for the Java plugin.

jsp:element Defines XML elements dynamically.

jsp:attribute Defines dynamically-defined XML element's

attribute.
jsp:body Defines dynamically-defined XML element's body.

jsp:text Used to write template text in JSP pages and

documents.

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 object associated

with the request.
 response This is the HttpServletResponse object associated
with the response to the client.

out This is the PrintWriter object used to send output

to the client.

session This is the HttpSession object associated with the

request.

application This is the ServletContext object associated

with application context.

config This is the ServletConfig object associated with the

page.

pageContext This encapsulates use of server-specific features like

higher performance JspWriters.

page This is simply a synonym for this, and is used to

call the methods defined by the translated servlet
class.

Exception The Exception object allows the exception data to

be accessed by designated JSP.

Control-Flow Statements
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 the Scriptlet tags.
 <%!intday=3;%>
<html>
<head><title>IF...ELSEExample</title></head>
<body>
<%if(day==1|day==7){%>
<p>Todayisweekend</p>
<%}else{%>
<p>Todayisnotweekend</p>
<%}%>
</body>
</html>

The above code will generate the following result:

Now look at the following switch...case block which has been written a bit
differently using out.println() and inside Scriptletas:
 break;
case 1:
out.println("It\'sMonday.");
break;
case2:
out.println("It\'sTuesday.");
break;
case3:
out.println("It\'sWednesday.");
break;
case4:
out.println("It\'sThursday.");
break;
case5:
out.println("It\'sFriday.");
break;
default:
out.println("It'sSaturday.");
}
%>
</body>
</html>

The above code will generate the following result:

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++){ %>
<fontcolor="green"size="<%=fontSize%>"> JSP
Tutorial
</font><br/>
<%}%>
</body>
</html>

The above code will generate the following result:

Above example can be written using the while loop as follows:

<%! int fontSize; %>

<html>
<head><title>WHILE LOOP Example</title></head>
<body>
<%while(fontSize<=3){ %>
<fontcolor="green"size="<%=fontSize%>"> JSP
Tutorial
 </font><br/>
<%fontSize++;%>
<%}%>
</body>
</html>

The above code will generate the following result:

JSP Operators
JSP supports all the logical and arithmetic operators supported by Java.
Following table lists out 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 ++ -- ! ~ Right to 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 ?: Right to left

Assignment = += -= *= /= %= >>= Right to 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
The JSP directives provide directions and instructions to the container, telling it
how to handle certain aspects of the 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-dependent attributes, 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. These
instructions pertain to the current JSP 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 the page directive:

<%@ page attribute="value" %>

You can write the XML equivalent of the above syntax as follows:
<jsp:directive.page attribute="value"/>

Attributes
Following table lists out the attributes associated with page directive:
Attribute Purpose

buffer Specifies a buffering model for the output stream.

autoFlush Controls the behavior of the servlet output buffer.

contentType Defines the character encoding scheme.

Defines the URL of another JSP that reports on Java

errorPage
unchecked runtime exceptions.

Indicates if this JSP page is a URL specified by

isErrorPage
another JSP page's errorPage attribute.

Specifies a superclass that the generated servlet

extends
must extend.

Specifies a list of packages or classes for use in the

import
JSP as the Java import statement does for Java
classes.
Defines a string that can be accessed with the
info servlet's getServletInfo() method.

isThreadSafe Defines the threading model for the generated

servlet.
language Defines the programming language used in theJSP
page.
Specifies whether or not the JSP page participates in
session
HTTP sessions

Specifies whether or not the EL expression within

isELIgnored
the JSP page will be ignored.

isScriptingEnabled Determines if the scripting elements are allowed for

use.
 The buffer Attribute
The buffer attribute specifies the buffering characteristics for the server output
response object.
You may code a value of "none" to specify no buffering so that the servlet
output is immediately directed to the response object or you may code a
maximum buffer size in kilobytes, which directs the servlet to write to the buffer
before writing to the response object.
To direct the servlet to write the output directly to the response output object,
use the following:

<%@ page buffer="none" %>

Use the following to direct the servlet to write the output to a buffer of size not
less than 8 kilobytes:

<%@ page buffer="8kb" %>

The autoFlush Attribute

The autoFlush attribute specifies whether buffered output should be flushed
automatically when the buffer is filled, or whether an exception should be
raised to indicate the buffer overflow.
A value of true (default) indicates automatic buffer flushing and a value of
false throws an exception.
The following directive causes the servlet to throw an exception when the
servlet's output buffer is full:

<%@ page autoFlush="false" %>

This directive causes the servlet to flush the output buffer when full:

<%@ page autoFlush="true" %>

Usually, the buffer and the autoFlush attributes are coded on a single page
directive as follows:

<%@page buffer="16kb" autoflush="true" %>

 The contentType Attribute
The contentType attribute sets the character encoding for the JSP page and for
the generated response page. The default content type is text/html, which is
the standard content type for HTML pages.
If you want to write out XML from your JSP, use the following page directive:

<%@ page contentType="text/xml" %>

The following statement directs the browser to render the generated page as
HTML:

<%@ page contentType="text/html" %>

The following directive sets the content type as a Microsoft Word document:

<%@ page contentType="application/msword" %>

You can also specify the character encoding for the response. For example, if
you wanted to specify that the resulting page that is returned to the browser
uses ISOLatin1, you can use the following page directive:
<%@ page contentType="text/html:charset=ISO-8859-1" %>

The errorPage Attribute

The errorPage attribute tells the JSP engine which page to display if there is an
error while the current page runs. The value of the errorPage attribute is a
relative URL.
The following directive displays MyErrorPage.jsp when all uncaught exceptions
are thrown:

<%@ page errorPage="MyErrorPage.jsp" %>

The isErrorPage Attribute

The isErrorPage attribute indicates that the current JSP can be used as the
error page for another JSP.
The value of isErrorPage is either true or false. The default value of the
isErrorPage attribute is false.
 For example, the handleError.jsp sets the isErrorPage option to true because
it is supposed to handle errors:

<%@ page isErrorPage="true" %>

The extends Attribute

The extends attribute specifies a super class that the generated servlet must
extend.
For example, the following directive directs the JSP translator to generate the
servlet such that the servlet extends somePackage.SomeClass:

<%@ page extends="somePackage.SomeClass" %>

The import Attribute

The import attribute serves the same function as, and behaves like, the Java
import statement. The value for the import option is the name of the package
you want to import.
To import java.sql.*, use the following page directive:

<%@ page import="java.sql.*" %>

To import multiple packages, you can specify them separated by comma as

follows:

<%@ page import="java.sql.*, java.util.*" %>

By default, a container automatically imports java.lang.*, javax.servlet.*,

javax.servlet.jsp.*, and javax.servlet.http.*.

The info Attribute

The info attribute lets you provide a description of the JSP. The following is a
coding example:

<%@ page info="ThisJSPPageWrittenByZARA" %>

The isThreadSafe Attribute

The isThreadSafe option marks a page as being thread-safe. By default, all
JSPs are considered thread-safe. If you set the isThreadSafe option to false, the
 JSP engine makes sure that only one thread at a time is executing your JSP.
The following page directive sets the isThreadSafe option to false:

<%@ page isThreadSafe="false" %>

The language Attribute

The language attribute indicates the programming language used in scripting
the JSP page.
For example, because you usually use Java as the scripting language, your
language option looks like this:

<%@ page language="java" %>

The session Attribute

The session attribute indicates whether or not the JSP page uses HTTP
sessions. A value of true means that the JSP page has access to a built in
session object and a value of false means that the JSP page cannot access the
built in session object.
Following directive allows the JSP page to use any of the built in object session
methods such as session.getCreationTime() or session.getLastAccessTime():

<%@ page session="true" %>

The is ELIgnored Attribute

The isELIgnored attribute gives you the ability to disable the evaluation of
Expression Language (EL) expressions which has been introduced in JSP 2.0.
The default value of the attribute is true, meaning that expressions, ${...}, are
evaluated as dictated by the JSP specification. If the attribute is set to false,
then expressions are not evaluated but rather treated as static text.

Following directive sets an expression not to be evaluated:

<%@ page isELIgnored="false" %>

The isScriptingEnabled Attribute

The isScriptingEnabled attribute determines if the scripting elements are
allowed for use.
 The default value (true) enables scriptlets, expressions, and declarations. If
the attribute's value is set to false, a translation-time error will be raised if the
JSP uses any scriptlets, expressions (non-EL), or declarations.
The attribute’s value can be set to false if you want to restrict the usage of
scriptlets, expressions (non-EL), or declarations:

<%@ page isScriptingEnabled="false" %>

The include Directive

The include directive is used to include 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 the include directives
anywhere in your JSP page.
The general usage form of this directive is as follows:

<%@ include file="relativeurl">

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.
You can write the XML equivalent of the above syntax as follows:

<jsp:directive.include file="relativeurl" />

Example
A good example of the include directive is including a common header and
footer with multiple pages of content.
Let us define following three files (a)header.jps, (b)footer.jsp, and (c)main.jsp
as follows:
Followingisthecontentofheader.jsp:
 <%!
intpageCount=0; void
addCount() {
pageCount++;
}
%>
<%addCount();%>
<html>
<head>
<title>TheincludeDirectiveExample</title>
</head>
<body>
<center>
<h2>TheincludeDirectiveExample</h2>
<p>Thissitehasbeenvisited<%=pageCount%>times.</p>
</center>
<br/><br/>

Following is the content of footer.jsp:

<%@includefile="header.jsp"%>
<center>
<p>Thanksforvisitingmypage.</p>
</center>
<%@includefile="footer.jsp"%>

Let us now keep all these files in the root directory and try to access main.jsp.
You will receive the following output:
 Refresh main.jsp and you will find that the page hit counter keeps increasing.
You can design your web pages based on your creative instincts; it is
recommended you keep the dynamic parts of your website in separate files and
then include them in the main file. This makes it easy when you need to
change a part of your webpage.

The taglib Directive

The Java Server Pages API allow 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 means for identifying the
custom tags in your JSP page.
The taglib directive follows the syntax given below:
 <%@ taglib uri="uri" prefix="prefixOfTag">

Here, 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.
You can write the XML equivalent of the above syntax as follows:

<jsp:directive.taglib uri="uri" prefix="prefixOfTag"/>

When you use a custom tag, it is typically of the form <prefix:tagname>. The
prefix is the same as the prefix you specify in the taglib directive, and the tag
name is the name of a tag implemented in the tag library.

Example
For example, suppose the custlib tag library contains a tag called hello. If you
wanted to use the hello tag with a prefix of mytag, your tag would be
<mytag:hello> and it will be used in your JSP file as follows:

<%@ taglib uri="http://www.example.com/custlib" prefix="mytag" %>

<html>

<body>

<mytag:hello/>

</body>
</html>

We can call another piece of code using <mytag:hello>.