JSP

JSP
JSP technology can be thought of as an extension to servlet because it provides more

functionality than servlet such as expression language, jstl etc. A JSP page consists of
HTML tags and JSP tags. The jsp pages are easier to maintain than servlet because we
can separate designing and development. It provides some additional features such as
Expression Language, Custom Tag etc.
Advantage of JSP over Servlet

1) Extension to Servlet
We can use all the features of servlet in JSP. In addition to, we can use implicit objects,
predefined tags, expression language and Custom tags in JSP, that makes JSP
development easy.
2) Easy to maintain
JSP can be easily managed because we can easily separate our business logic with
presentation logic. In servlet technology, we mix our business logic with the presentation
logic.
3) Fast Development: No need to recompile and redeploy
If JSP page is modified, we don't need to recompile and redeploy the project. The servlet
code needs to be updated and recompiled if we have to change the look and feel of the
application.
4) Less code than Servlet
In JSP, we can use a lot of tags such as action tags, jstl, custom tags etc. that reduces
the code. Moreover, we can use EL, implicit objects etc.
Life cycle of a JSP Page

The JSP pages follows these phases:
 Translation of JSP Page

 Compilation of JSP Page
 Classloading (class file is loaded by the classloader)
 Instantiation (Object of the Generated Servlet is created).
 Initialization ( jspInit() method is invoked by the container).
 Reqeust processing ( _jspService() method is invoked by the container).
 Destroy ( jspDestroy() method is invoked by the container).
Note: jspInit(), _jspService() and jspDestroy() are the life cycle methods of JSP.
As depicted in the above diagram, JSP page is translated into servlet by the help of JSP
translator. The JSP translator is a part of webserver that is responsible to translate the
JSP page into servlet. Afterthat Servlet page is compiled by the compiler and gets
converted into the class file.
Creating a simple JSP Page

To create the first jsp page, write some html code as given below, and save it by .jsp
extension. We have save this file as index.jsp. Put it in a folder and paste the folder in
the web-apps directory in apache tomcat to run the jsp page.
index.jsp
<body>
<% out.print(2*5); %>
</body>
It will print 10 on the browser.
How to run a simple JSP Page?

Follow the following steps to execute this JSP page:
 Start the server

 put the jsp file in a folder and deploy on the server
 visit the browser by the url http://localhost:portno/contextRoot/jspfile e.g.
http://localhost:8888/myapplication/index.jsp
Do I need to follow directory structure to run a simple JSP ?

No, there is no need of directory structure if you don't have class files or tld files. For
example, put jsp files in a folder directly and deploy that folder.It will be running fine.But
if you are using bean class, Servlet or tld file then directory structure is required.
Directory structure of JSP

The directory structure of JSP page is same as servlet. We contains the jsp page outside
the WEB-INF folder or in any directory.
The JSP API
The JSP API consists of two packages:
1. javax.servlet.jsp
2. javax.servlet.jsp.tagext
javax.servlet.jsp package
The javax.servlet.jsp package has two interfaces and classes.The two interfaces are as
follows:
1. JspPage
2. HttpJspPage
The classes are as follows:
 JspWriter
 PageContext
 JspFactory
 JspEngineInfo
 JspException
 JspError
The JspPage interface
According to the JSP specification, all the generated servlet classes must implement the
JspPage interface. It extends the Servlet interface. It provides two life cycle methods.
Methods of JspPage interface
1. public void jspInit(): It is invoked only once during the life cycle of the JSP
when JSP page is requested firstly. It is used to perform initialization. It is same
as the init() method of Servlet interface.
2. public void jspDestroy(): It is invoked only once during the life cycle of the JSP
before the JSP page is destroyed. It can be used to perform some clean up
operation.
The HttpJspPage interface
The HttpJspPage interface provides the one life cycle method of JSP. It extends the
JspPage interface.
Method of HttpJspPage interface:
1. public void _jspService(): It is invoked each time when request for the JSP
page comes to the container. It is used to process the request. The underscore _
signifies that you cannot override this method.
Scripting elements
The scripting elements provides the ability to insert java code inside the jsp. There are
three types of scripting elements:
 scriptlet tag
 expression tag
 declaration tag
JSP scriptlet tag

A scriptlet tag is used to execute java source code in JSP. Syntax is as follows:
<html>
<body>
<% out.print("welcome to jsp"); %>
</body>
</html>
Example of JSP scriptlet tag that prints the user name

index.html
<html>
<body>
<form action="welcome.jsp">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
</body>
</html>
welcome.jsp
<html>
<body>
<%
String name=request.getParameter("uname");
out.print("welcome "+name);
%>
</form>
</body>
</html>
JSP expression tag

The code placed within expression tag is written to the output stream of the response.
So you need not write out.print() to write data. It is mainly used to print the values of
variable or method.
<html>
<body>
Current Time: <%= java.util.Calendar.getInstance().getTime() %>
</body>
</html>
JSP Declaration Tag

The JSP declaration tag is used to declare fields and methods.The code written inside the
jsp declaration tag is placed outside the service() method of auto generated servlet.So it
doesn't get memory at each request
Difference between the jsp scriptlet tag and jsp declaration tag
?
Jsp Scriptlet Tag Jsp Declaration Tag
The jsp scriptlet tag can only declare The jsp declaration tag can declare
variables not methods. variables as well as methods.
The declaration of scriptlet tag is placed The declaration of jsp declaration tag is
inside the _jspService() method. placed outside the _jspService() method.
Example of JSP declaration tag that declares method

index.jsp
<html>
<body>
<%!
int cube(int n){
return n*n*n*;
%>
<%= "Cube of 3 is:"+cube(3) %>
</body>
</html>
JSP Implicit Objects

There are 9 jsp implicit objects. These objects are created by the web container
that are available to all the jsp pages.
JSP directives
The jsp directives are messages that tells the web container how to translate a JSP
page into the corresponding servlet. A JSP directive affects the overall structure of the servlet
class.
<%@ directive attribute="value" %>
There are three types of directives:
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
JSP page directive

The page directive defines attributes that apply to an entire JSP page
<%@ page attribute="value" %>
Attributes of JSP page directive
 import
 contentType
 extends
 info
 buffer
 language
 isELIgnored
 isThreadSafe
 autoFlush
 session
 pageEncoding
 errorPage
 isErrorPage
1)import
The import attribute is used to import class,interface or all the members of a
package.It is similar to import keyword in java class or interface.
<body>
<%@ page import="java.util.Date" %>
Today is: <%= new Date() %>
</body>
2)contentType
The contentType attribute defines the MIME(Multipurpose Internet Mail Extension) type
of the HTTP response.The default value is "text/html;charset=ISO-8859-1".
<body>
<%@ page contentType=application/msword %>
Today is: <%= new java.util.Date() %>

</body>
3)extends
The extends attribute defines the parent class that will be inherited by the generated
servlet
4)info
This attribute simply sets the information of the JSP page which is retrieved later by
using getServletInfo() method of Servlet interface.
<body>
<%@ page info="composed by Sonoo Jaiswal" %>
</body>
The web container will create a method getServletInfo() in the resulting servlet.For
example:
public String getServletInfo() {
return "composed by Sonoo Jaiswal";
5)buffer
The buffer attribute sets the buffer size in kilobytes to handle output generated by the
JSP page.The default size of the buffer is 8Kb.
<body>
<%@ page buffer="16kb" %>
</body>
6)language
The language attribute specifies the scripting language used in the JSP page. The default
value is "java".
7)isELIgnored
We can ignore the Expression Language (EL) in jsp by the isELIgnored attribute. By
default its value is false i.e. Expression Language is enabled by default.
<%@ page isELIgnored="true" %>//Now EL will be ignored
)isThreadSafe
Servlet and JSP both are multithreaded.If you want to control this behaviour of JSP
page, you can use isThreadSafe attribute of page directive.The value of isThreadSafe
value is true.If you make it false, the web container will serialize the multiple
requests, i.e. it will wait until the JSP finishes responding to a request before passing
another request to it.
9)errorPage
The errorPage attribute is used to define the error page, if exception occurs in the
current page, it will be redirected to the error page.
//index.jsp
<body>
<%@ page errorPage="myerrorpage.jsp" %>
<%= 100/0 %>
</body>
10)isErrorPage
The isErrorPage attribute is used to declare that the current page is the error page.
Note: The exception object can only be used in the error page.
//myerrorpage.jsp
<body>
<%@ page isErrorPage="true" %>
Sorry an exception occured!<br/>
The exception is: <%= exception %>

</body>
Jsp Include Directive

The include directive is used to include the contents of any resource it may be jsp file, html
file or text file. This directive tells the container to merge the content of other external files
with the current JSP during the translation phase.
Advantage of Include directive Code Reusability
<body>
<%@ include file="header.html" %>
Today is: <%= java.util.Calendar.getInstance().getTime() %>
</body>
The include directive includes the original content, so the actual page size grows at
runtime.
JSP Taglib directive

The JSP taglib directive is used to define a tag library that defines many tags. We use the
TLD (Tag Library Descriptor) file to define the tags.
In this example, we are using our tag named currentDate. To use this tag we must
specify the taglib directive so the container may get information about the tag.
<body>
<%@ taglib uri="http://www.javatpoint.com/tags" prefix="mytag" %>
<mytag:currentDate/>
</body>
Exception Handling in JSP

The exception is normally an object that is thrown at runtime. Exception Handling is the
process to handle the runtime errors. In JSP, there are two ways to perform exception
handling:
1. By errorPage and isErrorPage attributes of page directive

2. By <error-page> element in web.xml file
Example of exception handling in jsp by the elements of page
directive
In this case, you must define and create a page to handle the exceptions. The pages
where may occur exception, define the errorPage attribute of page directive.
 index.jsp for input values

 process.jsp for dividing the two numbers and displaying the result
 error.jsp for handling the exception
index.jsp
process.jsp
error.jsp
Example of exception handling in jsp by specifying the error-
page element in web.xml file
This approach is better because you don't need to specify the errorPage attribute in each jsp
page. In this case, either specify exception-type or error-code with the location element. If
you want to handle all the exception, you will have to specify the java.lang.Exception in the
exception-type element.
 web.xml file for specifying the error-page element

 index.jsp for input values
 process.jsp for dividing the two numbers and displaying the result
 error.jsp for displaying the exception
1) web.xml file
If you know any specific error code and you want to handle that exception, specify the
error-code element instead of exception-type as given below:
2) index.jsp
3) process.jsp
4) error.jsp
JSP Action Tags (Action Elements)
There are many JSP action tags or elements. Each tag is used to perform some specific
tasks. The action tags basically are used to control the flow between pages and to use
Java Bean. engine. You can dynamically insert a file, reuse JavaBeans components,
forward the user to another page, or generate HTML for the Java plugin.
Common Attributes:
There are two attributes that are common to all Action elements: the id attribute and the scope attribute.
 Id attribute: The id attribute uniquely identifies the Action element, and allows the action to be referenced inside
the JSP page. If the Action creates an instance of an object the id value can be used to reference it through the
implicit object PageContext
Scope attribute: This attribute identifies the lifecycle of the Action element. The id attribute and the scope attribute
are directly related, as the scope attribute determines the lifespan of the object associated with the id. The scope
attribute has four possible values: (a) page, (b)request, (c)session, and (d) application.
jsp:forward action tag
The jsp:forward action tag is used to forward the request to another resource it may be jsp, html or another
resource
Example of jsp:forward action tag without parameter

index.jsp
printdate.jsp
Example of jsp:forward action tag with parameter

In this example, we are forwarding the request to the printdate.jsp file with parameter and printdate.jsp file
prints the parameter value with date and time.
index.jsp
printdate.jsp
jsp:include action tag

The jsp:include action tag is used to include the content of another resource it may be jsp, html or
servlet. The jsp include action tag includes the resource at request time so it is better for dynamic
pages because there might be changes in future.
Example of jsp:include action tag without parameter

index.jsp
printdate.jsp
Java Bean
A Java Bean is a java class that should follow following conventions:
 It should have a no-arg constructor.

 It should be Serializable.
 It should provide methods to set and get the values of the properties, known as getter and setter
methods.
Simple example of java bean class
Employee.java
jsp:useBean action tag
The jsp:useBean action tag is used to locate or instantiate a bean class. If bean object of the Bean class is already
created, it doesn't create the bean depending on the scope. But if object of bean is not created, it instantiates the
bean.
1. id: is used to identify the bean in the specified scope.

2. scope: represents the scope of the bean. It may be page, request, session or application. The default
scope is page.
o page: specifies that you can use this bean within the JSP page. The default scope is page.
o request: specifies that you can use this bean from any JSP page that processes the same
request. It has wider scope than page.
o session: specifies that you can use this bean from any JSP page in the same session whether
processes the same request or not. It has wider scope than request.
o application: specifies that you can use this bean from any JSP page in the same application.
It has wider scope than session.
3. class: instantiates the specified bean class (i.e. creates an object of the bean class) but it must have
no-arg or no constructor and must not be abstract.
4. type: provides the bean a data type if the bean already exists in the scope. It is mainly used with class
or beanName attribute. If you use it without class or beanName, no bean is instantiated.
5. beanName: instantiates the bean using the java.beans.Beans.instantiate() method.
Calculator.java (a simple Bean class)
index.jsp file
jsp:setProperty and jsp:getProperty action tags

In web devlopment, bean class is mostly used because it is a reusable software component that represents
data. The jsp:setProperty action tag sets a property value or values in a bean using the setter method.
Example of jsp:setProperty action tag if you have to set all the values of incoming request
in the bean
<jsp:setProperty name="bean" property="*" />
Example of jsp:setProperty action tag if you have to set value of the incoming specific
property
<jsp:setProperty name="bean" property="username" value="Kumar" />
jsp:getProperty action tag

The jsp:getProperty action tag returns the value of the property.
<jsp:getProperty name="instanceOfBean" property="propertyName" />
Example of bean development in JSP
index.html
process.jsp
User.java
Reusing Bean in Multiple Jsp Pages
index.jsp User.java
Same as above.
process.jsp
second.jsp
Using variable value in setProperty tag
In some case, you may get some value from the database, that is to be set in the bean object, in such case, you
need to use expression tag.
Expression Language (EL) in JSP

The Expression Language (EL) simplifies the accessibility of data stored in the Java Bean component, and
other objects like request, session, application etc.There are many implicit objects, operators and reserve words
in EL.It is the newly added feature in JSP technology version 2.0.
${ expression }
Implicit Objects in Expression Language (EL)
The index.jsp file gets input from the user and sends the request to the process.jsp which in turn prints the name
of the user using EL
index.jsp
process.jsp
Welcome, ${ param.name }
Example of Expression Language that prints the value set in the session
scope
index.jsp
process.jsp
Value is ${ sessionScope.user }
MVC in JSP
MVC stands for Model View and Controller. It is a design pattern that separates the business logic,
presentation logic and data.
Controller acts as an interface between View and Model. Controller intercepts all the incoming requests.
Model represents the state of the application i.e. data. It can also have business logic.
View represents the presentaion i.e. UI(User Interface).
Advantage of MVC (Model 2) Architecture
1. Navigation Control is centralized

2. Easy to maintain the large application
Example of following MVC in JSP

index.jsp
ControllerServlet
LoginBean.java
login-success.jsp
login-error.jsp
<p>Sorry! username or password error</p>
<%@ include file="index.jsp" %>
web.xml
JSTL (JSP Standard Tag Library)
The JSP Standard Tag Library (JSTL) represents a set of tags(maimly 5 types) to simplify the JSP development.
Advantage of JSTL
1. Fast Developement JSTL provides many tags that simplifies the JSP.
2. Code Reusability We can use the JSTL tags in various pages.
3. No need to use scriptlet tag It avoids the use of scriptlet tag.
Tag Name Description
core tags The JSTL core tag provide variable support, URL management, flow control etc. The
url for the core tag is http://java.sun.com/jsp/jstl/core . The prefix of core
tag is c.
sql tags The JSTL sql tags provide SQL support. The url for the sql tags is
http://java.sun.com/jsp/jstl/sql and prefix is sql.
xml tags The xml sql tags provide flow control, transformation etc. The url for the xml tags
is http://java.sun.com/jsp/jstl/xml and prefix is x.
internationalization The internationalization tags provide support for message formatting, number and
tags date formatting etc. The url for the internationalization tags is
http://java.sun.com/jsp/jstl/fmt and prefix is fmt.
functions tags The functions tags provide support for string manipulation and string length. The
url for the functions tags is http://java.sun.com/jsp/jstl/functions and prefix
is fn.
For creating JSTL application, you need to load jstl.jar file.
JSTL Core Tags

The JSTL core tags mainly provides 4 types of tags:
 miscellaneous tags: catch and out.

 url management tags: import, redirect and url.
 variable support tags: remove and set.
 flow control tags: forEach, forTokens, if and choose.
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
c:catch
It is an alternative apporach of global exception handling of JSP. It handles the exception and doesn't propagate
the exception to error page. The exception object thrown at runtime is stored in a variable named var

<c:catch>
int a=10/0;
</c:catch>
c:out
It is just like JSP expression tag but it is used for exression. It renders data to the page
index.jsp
<form action="process.jsp" method="post">
FirstName:<input type="text" name="fname"/><br/>
LastName:<input type="text" name="lname"/><br/>
<input type="submit" value="submit"/>
</form>
process.jsp
First Name:<c:out value="${param.fname}"></c:out><br/>
Last Name:<c:out value="${param.lname}"></c:out>
c:import
It is just like jsp include but it can include the content of any resource either within server or outside the server.
Let's see the simple example of c:import to display the source code of other site.
index.jsp

<h1>ABC.com</h1>
<hr/>
<c:import var="data" url="http://www.javatpoint.com"></c:import>
<h2>Data is:</h2>
<c:out value="${data}"></c:out>
c:forEach
It repeats the nested body content for fixed number of times or over collection

<c:forEach var="number" begin="5" end="10">
<c:out value="${number}"></c:out>
</c:forEach>
c:if
It tests the condition.

<c:set var="number" value="${200}">
<c:if test="${number<500}">
<c:out value="number is less than 500"></c:out>
</c:if>
c:redirect
It redirects the request to the given url.

<c:redirect url="http://www.javatpoint.com"></c:redirect>
Custom Tags in JSP
Custom tags are user-defined tags. They eliminates the possibility of scriptlet tag and separates the business
logic from the JSP page.
The same business logic can be used many times by the use of costom tag
Example of JSP Custom Tag

In this example, we are going to create a custom tag that prints the current date and time. We are
performing action at the start of tag.
For creating any custom tag
1. Create the Tag handler class and perform action at the start or at the end of the tag.
2. Create the Tag Library Descriptor (TLD) file and define tags
3. Create the JSP file that uses the Custom tag defined in the TLD file
1) Create the Tag handler class
To create the Tag Handler, we are inheriting the TagSupport class and overriding its method doStartTag().To
write data for the jsp, we need to use the JspWriter class.
The PageContext class provides getOut() method that returns the instance of JspWriter class. TagSupport
class provides instance of pageContext bydefault.
package com.javatpoint.sonoo;
import java.util.Calendar;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;
public class MyTagHandler extends TagSupport{
public int doStartTag() throws JspException {
JspWriter out=pageContext.getOut();//returns the instance of JspWriter
try{
out.print(Calendar.getInstance().getTime());//printing date and time using JspWriter
}catch(Exception e){System.out.println(e);}
return SKIP_BODY;//will not evaluate the body content of the tag
}
}
2) Create the TLD file
Tag Library Descriptor (TLD) file contains information of tag and Tag Hander classes. It must be contained
inside the WEB-INF directory.
mytags.tld
<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE taglib
PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>simple</short-name>
<uri>http://tomcat.apache.org/example-taglib</uri>
<tag>
<name>today</name>
<tag-class>com.javatpoint.sonoo.MyTagHandler</tag-class>
</tag>
</taglib>
3) Create the JSP file
Here, we are specifying the path of tld file directly. But it is recommended to use the uri name instead of full
path of tld file.It uses taglib directive to use the tags defined in the tld file.
index.jsp
<%@ taglib uri="WEB-INF/mytags.tld" prefix="m" %>
Current Date and Time is: <m:today/>

JSP

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

JSP

Caricato da

Copyright:

Formati disponibili

JSP

JSP technology can be thought of as an extension to servlet because it provides more

Advantage of JSP over Servlet

3) Fast Development: No need to recompile and redeploy

4) Less code than Servlet

Life cycle of a JSP Page

 Translation of JSP Page

Creating a simple JSP Page

How to run a simple JSP Page?

 Start the server

Do I need to follow directory structure to run a simple JSP ?

Directory structure of JSP

The classes are as follows:

The JspPage interface

The HttpJspPage interface

Method of HttpJspPage interface:

JSP scriptlet tag

Example of JSP scriptlet tag that prints the user name

<input type="text" name="uname">

<input type="submit" value="go"><br/>

JSP expression tag

Current Time: <%= java.util.Calendar.getInstance().getTime() %>

JSP Declaration Tag

Example of JSP declaration tag that declares method

int cube(int n){

<%= "Cube of 3 is:"+cube(3) %>

JSP Implicit Objects

<%@ directive attribute="value" %>

There are three types of directives:

JSP page directive

<%@ page attribute="value" %>

Attributes of JSP page directive

<%@ page import="java.util.Date" %>

Today is: <%= new Date() %>

<%@ page contentType=application/msword %>

Today is: <%= new java.util.Date() %>

<%@ page info="composed by Sonoo Jaiswal" %>

Today is: <%= new java.util.Date() %>

public String getServletInfo() {

return "composed by Sonoo Jaiswal";

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

Today is: <%= new java.util.Date() %>

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

<%= 100/0 %>

<%@ page isErrorPage="true" %>

Sorry an exception occured!<br/>

The exception is: <%= exception %>

Jsp Include Directive

Advantage of Include directive Code Reusability

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

Today is: <%= java.util.Calendar.getInstance().getTime() %>

JSP Taglib directive

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

Exception Handling in JSP

1. By errorPage and isErrorPage attributes of page directive

 index.jsp for input values

 web.xml file for specifying the error-page element

Example of jsp:forward action tag without parameter

Example of jsp:forward action tag with parameter

jsp:include action tag

Example of jsp:include action tag without parameter

 It should have a no-arg constructor.

Simple example of java bean class