JSP Tutorial

JSP Tutorial
JSP technology is used to create web application just like Servlet technology. It
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
There are many advantages of JSP over servlet. They are as follows:
1) Extension to Servlet
JSP technology is the extension to servlet technology. 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. Moreover, all the processes that
happens in servlet is performed on JSP later like initialization, committing
response to the browser and destroy.
1.
2.
3.
4.
5.
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
Let's see the simple example of JSP, here we are using the scriptlet tag to put
java code in the JSP page. We will learn scriptlet tag later.
<html>
<body>
<% out.print(2*5); %>
</body>
</html>
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.
JSP Scriptlet tag (Scripting elements)
In JSP, java code can be written inside the jsp page using the scriptlet tag. Let's
see what are the scripting elements first.
Scripting elements
The scripting elements provides the ability to insert java code inside the jsp.
There are three types of scripting elements:
o
o
o
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:
1.
<% java source code %>

Example of JSP scriptlet tag
In this example, we are displaying a welcome message.
1.
2.
3.
4.
5.
<html>
<body>
<% out.print("welcome to jsp"); %>
</body>
</html>
Example of JSP scriptlet tag that prints the user name
In this example, we have created two files index.html and welcome.jsp. The
index.html file gets the username from the user and the welcome.jsp file prints
the username with the welcome message.
File: index.html
1.
2.
3.
4.
5.
6.
7.
8.
1.
2.
3.
4.
5.
6.
7.
8.
9.
1.
1.
2.
3.
4.
5.
1.
2.
3.
4.
5.
1.
<html>
<body>
<form action="welcome.jsp">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
</body>
</html>
File: welcome.html
<html>
<body>
<%
String name=request.getParameter("uname");
out.print("welcome "+name);
%>
</form>
</body>
</html>
JSP expression tag
The code placed within JSP 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.
Syntax of JSP expression tag
<%= statement %>
Example of JSP expression tag
In this example of jsp expression tag, we are simply displaying a welcome
message.
<html>
<body>
<%= "welcome to jsp" %>
</body>
</html>
Note: Do not end your statement with semicolon in case of expression tag.
Example of JSP expression tag that prints current time
To display the current time, we have used the getTime() method of Calendar
class. The getTime() is an instance method of Calendar class, so we have called
it after getting the instance of Calendar class by the getInstance() method.
index.jsp
<html>
<body>
Current Time: <%= java.util.Calendar.getInstance().getTime() %>
</body>
</html>
Example of JSP expression tag that prints the user name
In this example, we are printing the username using the expression tag. The
index.html file gets the username and sends the request to the welcome.jsp file,
which displays the username.
File: index.jsp
<html>
2.
3.
4.
5.
6.
7.
8.
<body>
<form action="welcome.jsp">
<input type="text" name="uname"><br/>
<input type="submit" value="go">
</form>
</body>
</html>
File: welcome.jsp
1.
<html>
2.
<body>
3.
<%= "Welcome "+request.getParameter("uname") %>
4.
</body>
5.
</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.
Syntax of JSP declaration tag
The syntax of the declaration tag is as follows:
1.
<%! field or method declaration %>
Difference between JSP Scriptlet tag and Declaration tag
Jsp Scriptlet Tag
Jsp Declaration Tag
The jsp scriptlet tag can only declare
variables not methods.
The jsp declaration tag can declare variables

as well as methods.
The declaration of scriptlet tag is placed

inside the _jspService() method.
The declaration of jsp declaration tag is

placed outside the _jspService() method.
1.
2.
3.
4.
5.
6.
Example of JSP declaration tag that declares field

In this example of JSP declaration tag, we are declaring the field and printing the
value of the declared field using the jsp expression tag.
index.jsp
<html>
<body>
<%! int data=50; %>
<%= "Value of the variable is:"+data %>
</body>
</html>
1.
2.
3.
4.
5.
Example of JSP declaration tag that declares method

In this example of JSP declaration tag, we are defining the method which returns
the cube of given number and calling this method from the jsp expression tag.
But we can also use jsp scriptlet tag to call the declared method.
index.jsp
<html>
<body>
<%!
int cube(int n){
return n*n*n*;
6.
7.
8.
9.
10.
}
%>
<%= "Cube of 3 is:"+cube(3) %>
</body>
</html>
JSP Implicit Objects

There are 9 jsp implicit objects. These objects are created by the web
containerthat are available to all the jsp pages.
The available implicit objects are out, request, config, session, application etc.
A list of the 9 implicit objects is given below:
Object
Type
out
JspWriter
request
HttpServletRequest
response
HttpServletResponse
config
ServletConfig
application
ServletContext
session
HttpSession
pageContext
PageContext
page
Object
exception
Throwable
1) JSP out implicit object

For writing any data to the buffer, JSP provides an implicit object named out. It
is the object of JspWriter. In case of servlet you need to write:
1.
PrintWriter out=response.getWriter();
But in JSP, you don't need to write this code.
Example of out implicit object
In this example we are simply displaying date and time.
index.jsp
1.
<html>
2.
<body>
3.
<% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %>
4.
5.
</body>
</html>
JSP directives
The jsp directives are messages that tells the web container how to translate a
JSP page into the corresponding servlet.
There are three types of directives:
page directive
include directive
taglib directive
Syntax of JSP Directive
1.
<%@ directive attribute="value" %>
JSP page directive

The page directive defines attributes that apply to an entire JSP page.
Syntax of JSP page directive
1.
<%@ 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.
1.
2.
3.
4.
5.
6.
7.
8.
Example of import attribute

<html>
<body>
<%@ page import="java.util.Date" %>
Today is: <%= new Date() %>
</body>
</html>
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".
Example of contentType attribute
1.
<html>
2.
<body>
3.
4.
<%@ page contentType=application/msword %>
5.
Today is: <%= new java.util.Date() %>
6.
7.
</body>
8.
</html>
3)extends
The extends attribute defines the parent class that will be inherited by the
generated servlet.It is rarely used.
4)info
This attribute simply sets the information of the JSP page which is retrieved later
by using getServletInfo() method of Servlet interface.
Example of info attribute
1.
<html>
2.
<body>
3.
4.
<%@ page info="composed by Sonoo Jaiswal" %>
5.
6.
7.
</body>
8.
</html>
The web container will create a method getServletInfo() in the resulting
servlet.For example:
1.
public String getServletInfo() {
2.
return "composed by Sonoo Jaiswal";
3.
}
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.
Example of buffer attribute
1.
<html>
2.
<body>
3.
4.
<%@ page buffer="16kb" %>
5.
6.
7.
</body>
8.
</html>
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. We see Expression Language later.
1.
<%@ page isELIgnored="true" %>//Now EL will be ignored
8)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.If you make the value of
isThreadSafe attribute like:
1.
2.
3.
4.
<%@ page isThreadSafe="false" %>

The web container in such a case, will generate the servlet as:
public class SimplePage_jsp extends HttpJspBase
implements SingleThreadModel{
.......
}
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.
Example of errorPage attribute
1.
//index.jsp
2.
<html>
3.
<body>
4.
5.
<%@ page errorPage="myerrorpage.jsp" %>
6.
7.
<%= 100/0 %>
8.
9.
</body>
10.
</html>
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.
Example of isErrorPage attribute
1.
//myerrorpage.jsp
2.
<html>
3.
<body>
4.
5.
<%@ page isErrorPage="true" %>
6.
7.
Sorry an exception occured!<br/>
8.
The exception is: <%= exception %>
9.
10.
</body>
11.
</html>
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. The include directive includes the original content of
the included resource at page translation time (the jsp page is translated only
once so it will be better to include static resource).
Advantage of Include directive
Code Reusability
Syntax of include directive
1.
<%@ include file="resourceName" %>
Example of include directive
In this example, we are including the content of the header.html file. To run this
example you must create an header.html file.
1.
<html>
2.
<body>
3.
4.
<%@ include file="header.html" %>
5.
6.
Today is: <%= java.util.Calendar.getInstance().getTime() %>
7.
8.
</body>
9.
</html>
Note: The include directive includes the original content, so the actual page size
grows at runtime.
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. There may occur exception
any time in your web application. So handling exceptions is a safer side for the
web developer. 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
1.
2.
3.
4.
5.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
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, as in
the error.jsp page. The pages where may occur exception, define the errorPage
attribute of page directive, as in the process.jsp page.
There are 3 files:
index.jsp for input values
process.jsp for dividing the two numbers and displaying the result
error.jsp for handling the exception
index.jsp
<form action="process.jsp">
No1:<input type="text" name="n1" /><br/><br/>
No1:<input type="text" name="n2" /><br/><br/>
<input type="submit" value="divide"/>
</form>
process.jsp
<%@ page errorPage="error.jsp" %>
<%
String num1=request.getParameter("n1");
String num2=request.getParameter("n2");
int a=Integer.parseInt(num1);
int b=Integer.parseInt(num2);
int c=a/b;
out.print("division of numbers is: "+c);
11.
12.
%>
error.jsp
1.
<%@ page isErrorPage="true" %>
2.
3.
<h3>Sorry an exception occured!</h3>
4.
5.
Exception is: <%= exception %>
MVC in JSP
1. MVC in JSP
2. Example of following 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
If you new to MVC, please visit Model1 vs Model2 first.

Example of following MVC in JSP
In this example, we are using servlet as a controller, jsp as a view component,
Java Bean class as a model.
In this example, we have created 5 pages:
index.jsp a page that gets input from the user.
ControllerServlet.java a servlet that acts as a controller.
login-success.jsp and login-error.jsp files acts as view components.
web.xml file for mapping the servlet.
File: index.jsp
1.
<form action="ControllerServlet" method="post">
2.
Name:<input type="text" name="name"><br>
3.
Password:<input type="password" name="password"><br>
4.
5.
<input type="submit" value="login">

</form>
File: ControllerServlet
1.
package com.javatpoint;
2.
import java.io.IOException;
3.
import java.io.PrintWriter;
4.
import javax.servlet.RequestDispatcher;
5.
import javax.servlet.ServletException;
6.
import javax.servlet.http.HttpServlet;
7.
import javax.servlet.http.HttpServletRequest;
8.
import javax.servlet.http.HttpServletResponse;
9.
public class ControllerServlet extends HttpServlet {
10.
protected void doPost(HttpServletRequest request, HttpServletRespon
se response)
11.
throws ServletException, IOException {
12.
response.setContentType("text/html");
13.
PrintWriter out=response.getWriter();
14.
15.
String name=request.getParameter("name");
16.
String password=request.getParameter("password");
17.
18.
LoginBean bean=new LoginBean();
19.
bean.setName(name);
20.
bean.setPassword(password);
21.
request.setAttribute("bean",bean);
22.
23.
boolean status=bean.validate();
24.
25.
if(status){
26.
RequestDispatcher rd=request.getRequestDispatcher("loginsuccess.jsp");
27.
rd.forward(request, response);
28.
}
29.
else{
30.
RequestDispatcher rd=request.getRequestDispatcher("loginerror.jsp");
31.
rd.forward(request, response);
32.
}
33.
34.
}
35.
36.
@Override
37.
protected void doGet(HttpServletRequest req, HttpServletResponse re
sp)
38.
throws ServletException, IOException {
39.
doPost(req, resp);
40.
}
41.
}
File: LoginBean.java
1.
package com.javatpoint;
2.
public class LoginBean {
3.
private String name,password;
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
public String getName() {

return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public boolean validate(){
if(password.equals("admin")){
return true;
}
else{
return false;
}
}
}
File: login-success.jsp
1.
<%@page import="com.javatpoint.LoginBean"%>
2.
3.
<p>You are successfully logged in!</p>
4.
<%
5.
LoginBean bean=(LoginBean)request.getAttribute("bean");
6.
out.print("Welcome, "+bean.getName());
7.
%>
File: login-error.jsp
1.
<p>Sorry! username or password error</p>
2.
<%@ include file="index.jsp" %>
File: web.xml
1.
<?xml version="1.0" encoding="UTF-8"?>
2.
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.
com/xml/ns/javaee/web-app_2_5.xsd"
4.
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.
com/xml/ns/javaee/web-app_3_0.xsd"
5.
id="WebApp_ID" version="3.0">
6.
7.
<servlet>
8.
<servlet-name>s1</servlet-name>
9.
<servlet-class>com.javatpoint.ControllerServlet</servlet-class>
10.
</servlet>
11.
<servlet-mapping>
12.
<servlet-name>s1</servlet-name>
13.
<url-pattern>/ControllerServlet</url-pattern>
14.
</servlet-mapping>
15.
</web-app>
Model 1 and Model 2 (MVC) Architecture

Before developing the web applications, we need to have idea about design
models. There are two types of programming models (design models)
1. Model 1 Architecture
2. Model 2 (MVC) Architecture
Model 1 Architecture
Servlet and JSP are the main technologies to develop the web applications.
Servlet was considered superior to CGI. Servlet technology doesn't create
process, rather it creates thread to handle request. The advantage of creating
thread over process is that it doesn't allocate separate memory area. Thus many
subsequent requests can be easily handled by servlet.
Problem in Servlet technology Servlet needs to recompile if any designing
code is modified. It doesn't provide separation of concern. Presentation and
Business logic are mixed up.
JSP overcomes almost all the problems of Servlet. It provides better separation
of concern, now presentation and business logic can be easily separated. You
don't need to redeploy the application if JSP page is modified. JSP provides
support to develop web application using JavaBean, custom tags and JSTL so that
we can put the business logic separate from our JSP that will be easier to test
and debug.
As you can see in the above figure, there is picture which show the flow of the
model1 architecture.
1. Browser sends request for the JSP page
2. JSP accesses Java Bean and invokes business logic
3. Java Bean connects to the database and get/save data
4. Response is sent to the browser which is generated by JSP

Advantage of Model 1 Architecture
Easy and Quick to develop web application
Disadvantage of Model 1 Architecture
Navigation control is decentralized since every page contains the

logic to determine the next page. If JSP page name is changed that is
referred by other pages, we need to change it in all the pages that leads to
the maintenance problem.
Time consuming You need to spend more time to develop custom tags in
JSP. So that we don't need to use scriptlet tag.
Hard to extend It is better for small applications but not for large
applications.
Model 2 (MVC) Architecture

Model 2 is based on the MVC (Model View Controller) design pattern. The MVC
design pattern consists of three modules model, view and controller.
Model The model represents the state (data) and business logic of the
application.
View The view module is responsible to display data i.e. it represents the
presentation.
Controller The controller module acts as an interface between view and model.
It intercepts all the requests i.e. receives input and commands to Model / View to
change accordingly.
Advantage of Model 2 (MVC) Architecture
Navigation control is centralized Now only controller contains

the logic to determine the next page.
Easy to maintain
Easy to extend
Easy to test
Better separation of concerns
Disadvantage of Model 2 (MVC) Architecture
We need to write the controller code self. If we change the controller

code, we need to recompile the class and redeploy the application.

JSP Tutorial

Uploaded by

Copyright:

Available Formats

JSP Tutorial

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

JSP Tutorial

Uploaded by

Copyright:

Available Formats

JSP Tutorial

Creating a simple JSP Page

JSP Scriptlet tag (Scripting elements)

JSP scriptlet tag

<% java source code %>

The jsp declaration tag can declare variables

The declaration of scriptlet tag is placed

The declaration of jsp declaration tag is

Example of JSP declaration tag that declares field

Example of JSP declaration tag that declares method

JSP Implicit Objects

1) JSP out implicit object

JSP page directive

Example of import attribute

<%@ page isThreadSafe="false" %>

Example of exception handling in jsp by the elements of page directive

If you new to MVC, please visit Model1 vs Model2 first.

<input type="submit" value="login">

public String getName() {

Model 1 and Model 2 (MVC) Architecture

4. Response is sent to the browser which is generated by JSP

Easy and Quick to develop web application

Disadvantage of Model 1 Architecture

Navigation control is decentralized since every page contains the

Model 2 (MVC) Architecture

Advantage of Model 2 (MVC) Architecture

Navigation control is centralized Now only controller contains

Better separation of concerns

Disadvantage of Model 2 (MVC) Architecture

We need to write the controller code self. If we change the controller

You might also like