Scribd
Upload
29 views99 pages

JSPT Notes

The JSP Tutorial provides an overview of JavaServer Pages (JSP) technology, highlighting its advantages over servlets, such as easier maintenance and faster development. It explains the JSP lifecycle, scripting elements, and how to create and run a simple JSP page, including examples of scriptlet and expression tags. Additionally, it covers the JSP API, implicit objects, and directives, along with instructions for creating JSP in Eclipse IDE with a Tomcat server.

Uploaded by

smi678925
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
29 views99 pages

JSPT Notes

The JSP Tutorial provides an overview of JavaServer Pages (JSP) technology, highlighting its advantages over servlets, such as easier maintenance and faster development. It explains the JSP lifecycle, scripting elements, and how to create and run a simple JSP page, including examples of scriptlet and expression tags. Additionally, it covers the JSP API, implicit objects, and directives, along with instructions for creating JSP in Eclipse IDE with a Tomcat server.

Uploaded by

smi678925
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 99

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.

Page 1
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.

Page 2
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. After that 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.

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.

Page 3
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.

1.​ <html>
2.​ <body>
3.​ <% out.print(2*5); %>
4.​ </body>
5.​ </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.

Page 4
OPICS of JSP Tutorial
1.​ JSP with Life cycle
2.​ JSP API
3.​ JSP in Eclipse
4.​ Scripting elements
o​ scriptlet tag
o​ expression tag
o​ declaration tag
5.​ Implicit Objects
6.​ Directive elements
o​ page directive
o​ include directive
o​ taglib directive
7.​ Exception Handling
8.​ Action Elements
9.​ Expression Language
10.​MVC in JSP
11.​JSTL
12.​Custom tags

Page 5
13.​Development in JSP

The JSP API


1.​ The JSP API
2.​ javax.servlet.jsp package
3.​ The JspPage interface
4.​ The HttpJspPage interface

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.

Page 6
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.

We will learn all other classes and interfaces later.

Page 7
Creating JSP in Eclipse IDE with Tomcat server
1.​ Creating JSP in Eclipse IDE with Tomcat
1.​ Create a Dynamic web project
2.​ create a jsp
3.​ start tomcat server and deploy the project

●​ Create a Dynamic web project


●​ create a jsp
●​ start tomcat server and deploy the project

1) Create the dynamic web project


For creating a dynamic web project click on File Menu -> New -> dynamic web
project -> write your project name e.g. first -> Finish.

Page 8
Page 9
Page 10
Page 11
Page 12
Page 13
2) Create the JSP file in eclipse IDE
For creating a jsp file explore the project by clicking the + icon -> right click on
WebContent -> New -> jsp -> write your jsp file name e.g. index -> next -> Finish.

Page 14
Page 15
Page 16
Page 17
Page 18
Page 19
Now JSP file is created, let's write some code.

Page 20
3) Start the server and deploy the project:
For starting the server and deploying the project in one step Right click on your
project -> Run As -> Run on Server -> choose tomcat server -> next -> addAll ->
finish.

If you are using Eclipse IDE first time, you need to configure the tomcat server
First. Click for How to configure tomcat server in eclipse IDE

Page 21
Now start the tomcat server and deploy project
For starting the server and deploying the project in one step Right click on your
project -> Run As -> Run on Server -> choose tomcat server -> next -> addAll ->
finish.

Page 22
Page 23
Page 24
Yes, Let's see JSP is successfully running now.

Page 25
JSP Scriptlet tag (Scripting elements)
1.​ Scripting elements
2.​ JSP scriptlet tag
3.​ Simple Example of JSP scriptlet tag
4.​ Example of JSP scriptlet tag that prints the user name

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

Page 26
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:

1.​ <% java source code %>

Simple Example of JSP scriptlet tag


In this example, we are displaying a welcome message.

1.​ <html>
2.​ <body>
3.​ <% out.print("welcome to jsp"); %>
4.​ </body>
5.​ </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.

index.html

1.​ <html>
2.​ <body>
3.​ <form action="welcome.jsp">

Page 27
4.​ <input type="text" name="uname">
5.​ <input type="submit" value="go"><br/>
6.​ </form>
7.​ </body>
8.​ </html>

welcome.jsp

1.​ <html>
2.​ <body>
3.​ <%
4.​ String name=request.getParameter("uname");
5.​ out.print("welcome "+name);
6.​ %>
7.​ </form>
8.​ </body>
9.​ </html>

JSP expression tag


1.​ JSP expression tag
2.​ Example of JSP expression tag
3.​ Example of JSP expression tag that prints current time
4.​ Example of JSP expression tag that prints the user name

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.
​
​

Syntax of JSP expression tag

1.​ <%= statement %>

Example of JSP expression tag


In this example of jsp expression tag, we are simply displaying a welcome
message.
1.​ <html>

Page 28
2.​ <body>
3.​ <%= "welcome to jsp" %>
4.​ </body>
5.​
6.​ </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

1.​ <html>
2.​ <body>
3.​ Current Time: <%= java.util.Calendar.getInstance().getTime() %>
4.​ </body>
5.​ </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.

index.html

1.​ <html>
2.​ <body>
3.​
4.​ <form action="welcome.jsp">
5.​ <input type="text" name="uname"><br/>
6.​ <input type="submit" value="go">

Page 29
7.​ </form>
8.​ </body>
9.​ </html>

welcome.jsp

1.​ <html>
2.​ <body>
3.​ <%= "Welcome "+request.getParameter("uname") %>
4.​ </form>
5.​ </body>
6.​ </html>

JSP Declaration Tag


1.​ JSP declaration tag
2.​ Difference between JSP scriptlet tag and JSP declaration tag
3.​ Example of JSP declaration tag that declares field
4.​ Example of JSP declaration tag that declares method

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 the jsp scriptlet tag and jsp


declaration tag ?
Jsp Scriptlet Tag Jsp Declaration Tag

Page 30
The jsp scriptlet tag can only declare The jsp declaration tag can declare variables
variables not methods. as well as methods.

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

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

1.​ <html>
2.​ <body>
3.​
4.​ <%! int data=50; %>
5.​ <%= "Value of the variable is:"+data %>
6.​
7.​ </body>
8.​ </html>

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

1.​ <html>
2.​ <body>
3.​
4.​ <%!
5.​ int cube(int n){
6.​ return n*n*n*;
7.​ }

Page 31
8.​ %>
9.​
10.​<%= "Cube of 3 is:"+cube(3) %>
11.​
12.​</body>
13.​</html>

JSP Implicit Objects


1.​ JSP Implicit Objects
2.​ out implicit object
3.​ Example of out implicit object

There are 9 jsp implicit objects. These objects arecreated by the web
container that 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) out implicit object

Page 32
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.​ </body>
5.​ </html>

Output

Upcoming topics in JSP implicit Objects


Example of Request implicit Object​
Example of Response implicit Object​
Example of config implicit object​

Page 33
Example of application implicit object​
Example of session implicit object​
Example of pageContext implicit object​
Example of page implicit object​
Example of exception implicit object

JSP directives
1.​ JSP directives
1.​ page directive
2.​ Attributes of page directive

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

Page 34
●​ 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.

Example of import attribute


1.​ <html>
2.​ <body>
3.​
4.​ <%@ page import="java.util.Date" %>
5.​ Today is: <%= new Date() %>
6.​
7.​ </body>
8.​ </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".

Page 35
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.​ Today is: <%= new java.util.Date() %>
6.​
7.​ </body>
8.​ </html>

The web container will create a method getServletInfo() in the resulting servlet.For
example:

1.​ public String getServletInfo() {

Page 36
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.​ Today is: <%= new java.util.Date() %>
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

Page 37
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:

<%@ page isThreadSafe="false" %>

The web container in such a case, will generate the servlet as:

1.​ public class SimplePage_jsp extends HttpJspBase


2.​ implements SingleThreadModel{
3.​ .......
4.​ }

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.

Page 38
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


1.​ Include directive
2.​ Advantage of Include directive
3.​ Example of 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

Page 39
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.

JSP Taglib directive


1.​ JSP Taglib directive
2.​ Example of 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 the custom tag
section we will use this tag so it will be better to learn it in custom tag.

Syntax JSP Taglib directive

1.​ <%@ taglib uri="uriofthetaglibrary" prefix="prefixoftaglibrary" %>

Example of JSP Taglib directive


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.

1.​ <html>
2.​ <body>
3.​
4.​ <%@ taglib uri="http://www.javatpoint.com/tags" prefix="mytag" %>

Page 40
5.​
6.​ <mytag:currentDate/>
7.​
8.​ </body>
9.​ </html>

Exception Handling in JSP


1.​ Exception Handling in JSP
2.​ Example of exception handling in jsp by the elements of page directive
3.​ Example of exception handling in jsp by specifying the error-page element in web.xml
file

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

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

1.​ <form action="process.jsp">

Page 41
2.​ No1:<input type="text" name="n1" /><br/><br/>
3.​ No1:<input type="text" name="n2" /><br/><br/>
4.​ <input type="submit" value="divide"/>
5.​ </form>

process.jsp

1.​ <%@ page errorPage="error.jsp" %>


2.​ <%
3.​
4.​ String num1=request.getParameter("n1");
5.​ String num2=request.getParameter("n2");
6.​
7.​ int a=Integer.parseInt(num1);
8.​ int b=Integer.parseInt(num2);
9.​ int c=a/b;
10.​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 %>

Output of this example:

Page 42
Page 43
Page 44
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. Specifying the single entry in the web.xml file will handle the
exception. 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. Let's see the simple example:

There are 4 files:

●​ 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 want to handle any exception

1.​ <web-app>
2.​
3.​ <error-page>
4.​ <exception-type>java.lang.Exception</exception-type>
5.​ <location>/error.jsp</location>
6.​ </error-page>
7.​
8.​ </web-app>

This approach is better if you want to handle any exception. 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:

1) web.xml file if you want to handle the exception for a specific error
code

1.​ <web-app>
2.​
3.​ <error-page>
4.​ <error-code>500</error-code>
5.​ <location>/error.jsp</location>

Page 45
6.​ </error-page>
7.​
8.​ </web-app>

2) index.jsp file is same as in the above example

3) process.jsp

Now, you don't need to specify the errorPage attribute of page directive in the jsp
page.
1.​ <%@ page errorPage="error.jsp" %>
2.​ <%
3.​
4.​ String num1=request.getParameter("n1");
5.​ String num2=request.getParameter("n2");
6.​
7.​ int a=Integer.parseInt(num1);
8.​ int b=Integer.parseInt(num2);
9.​ int c=a/b;
10.​out.print("division of numbers is: "+c);
11.​
12.​%>

4) error.jsp file is same as in the above example

JSP Action Tags (Action Elements)


1.​ JSP Action Tags
2.​ jsp:forward action tag
3.​ Example of jsp:forward action tag without parameter
4.​ Example of jsp:forward action tag with parameter

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. Jsp action tags are as follows:

●​ jsp:forward
●​ jsp:include
●​ jsp:useBean
●​ jsp:setProperty

Page 46
●​ jsp:getProperty
●​ jsp:plugin
●​ jsp:param
●​ jsp:fallback

The jsp:useBean, jsp:setProperty and jsp:getProperty tags are used for bean
development. So we will see these tags in bean developement.

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.

Syntax of jsp:forward action tag without parameter

1.​ <jsp:forward page="relativeURL | <%= expression %>" />

Syntax of jsp:forward action tag with parameter

1.​ <jsp:forward page="relativeURL | <%= expression %>">


2.​ <jsp:param name="parametername" value="parametervalue | <%=expression%>
" />
3.​ </jsp:forward>

Example of jsp:forward action tag without parameter


In this example, we are simply forwarding the request to the printdate.jsp file.

index.jsp

1.​ <html>
2.​ <body>
3.​ <h2>this is index page</h2>

Page 47
4.​
5.​ <jsp:forward page="printdate.jsp" />
6.​ </body>
7.​ </html>

printdate.jsp

1.​ <html>
2.​ <body>
3.​ <% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %>
4.​ </body>
5.​ </html>
download this example

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

1.​ <html>
2.​ <body>
3.​ <h2>this is index page</h2>
4.​
5.​ <jsp:forward page="printdate.jsp" >
6.​ <jsp:param name="name" value="javatpoint.com" />
7.​ </jsp:forward>
8.​
9.​ </body>
10.​</html>

printdate.jsp

1.​ <html>
2.​ <body>
3.​
4.​ <% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %>
5.​ <%= request.getParameter("name") %>
6.​

Page 48
7.​ </body>
8.​ </html>

jsp:include action tag


1.​ jsp:include action tag
2.​ Syntax of jsp:include action tag
3.​ Example of jsp:include action tag without parameter

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 pagesbecause there might be changes in future.

Advantage of jsp:include action tag

code reusability

Syntax of jsp:include action tag without parameter

1.​ <jsp:include page="relativeURL | <%= expression %>" />

Syntax of jsp:include action tag with parameter

1.​ <jsp:include page="relativeURL | <%= expression %>">


2.​ <jsp:param name="parametername" value="parametervalue | <%=expression%>
" />
3.​ </jsp:include>

Example of jsp:include action tag without parameter


In this example, index.jsp file includes the content of the printdate.jsp file.

File: index.jsp
1.​ <html>
2.​ <body>
3.​ <h2>this is index page</h2>

Page 49
4.​
5.​ <jsp:include page="printdate.jsp" />
6.​
7.​ <h2>end section of index page</h2>
8.​ </body>
9.​ </html>
File: printdate.jsp
1.​ <% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %>

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.

Why use Java Bean?


According to Java white paper, it is a reusable software component. A bean
encapsulates many objects into one object, so we can access this object from
multiple places. Moreover, it provides the easy maintenance.

Simple example of java bean class


1.​ //Employee.java
2.​
3.​ package mypack;
4.​ public class Employee implements java.io.Serializable{
5.​ private int id;
6.​ private String name;
7.​
8.​ public Employee(){}
9.​
10.​public void setId(int id){this.id=id;}
11.​
12.​public int getId(){return id;}
13.​
14.​public void setName(String name){this.name=name;}
15.​

Page 50
16.​public String getName(){return name;}
17.​
18.​}

How to access the java bean class?


To access the java bean class, we should use getter and setter methods.

1.​ package mypack;


2.​ public class Test{
3.​ public static void main(String args[]){
4.​
5.​ Employee e=new Employee();//object is created
6.​
7.​ e.setName("Arjun");//setting value to the object
8.​
9.​ System.out.println(e.getName());
10.​
11.​}}

Note: There are two ways to provide values to the object, one way is by
constructor and second is by setter method.

jsp:useBean action tag


1.​ jsp:useBean action tag
2.​ Syntax of jsp:useBean action tag
3.​ Attributes and Usage of jsp:useBean action tag
4.​ Simple example of 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.

Syntax of jsp:useBean action tag


1.​ <jsp:useBean id= "instanceName" scope= "page | request | session | application
"
2.​ class= "packageName.className" type= "packageName.className"
3.​ beanName="packageName.className | <%= expression >" >
4.​ </jsp:useBean>

Page 51
Attributes and Usage of jsp:useBean action tag
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.

Simple example of jsp:useBean action tag


In this example, we are simply invoking the method of the Bean class.

For the example of setProperty, getProperty and useBean tags, visit next
page.

Calculator.java (a simple Bean class)

1.​ package com.javatpoint;


2.​ public class Calculator{
3.​
4.​ public int cube(int n){return n*n*n;}
5.​

Page 52
6.​ }

index.jsp file

1.​ <jsp:useBean id="obj" class="com.javatpoint.Calculator"/>


2.​
3.​ <%
4.​ int m=obj.cube(5);
5.​ out.print("cube of 5 is "+m);
6.​ %>
download this example

jsp:setProperty and jsp:getProperty action tags


1.​ jsp:setProperty and jsp:getProperty action tags
2.​ Syntax of jsp:setProperty action tag
3.​ Example of jsp:setProperty
4.​ jsp:getProperty action tag
5.​ Syntax of jsp:getProperty action tag
6.​ Example of jsp:getProperty action tag
7.​ Example of bean development in JSP

Page 53
The setProperty and getProperty action tags are used for developing web
application with Java Bean. In web development, 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.

​
​

Syntax of jsp:setProperty action tag


1.​ <jsp:setProperty name="instanceOfBean" property= "*" |
2.​ property="propertyName" param="parameterName" |
3.​ property="propertyName" value="{ string | <%= expression %>}"
4.​ />

Example of jsp:setProperty action tag if you have to set all the values
of incoming request in the bean

1.​ <jsp:setProperty name="bean" property="*" />

Example of jsp:setProperty action tag if you have to set value of the


incoming specific property

1.​ <jsp:setProperty name="bean" property="username" />

Example of jsp:setProperty action tag if you have to set a specific


value in the property

1.​ <jsp:setProperty name="bean" property="username" value="Kumar" />

jsp:getProperty action tag

The jsp:getProperty action tag returns the value of the property.

Page 54
Syntax of jsp:getProperty action tag

1.​ <jsp:getProperty name="instanceOfBean" property="propertyName" />

Simple example of jsp:getProperty action tag

1.​ <jsp:getProperty name="obj" property="name" />

Example of bean development in JSP


In this example there are 3 pages:

●​ index.html for input of values


●​ welocme.jsp file that sets the incoming values to the bean object and prints
the one value
●​ User.java bean class that have setter and getter methods

index.html

1.​ <form action="process.jsp" method="post">


2.​ Name:<input type="text" name="name"><br>
3.​ Password:<input type="password" name="password"><br>
4.​ Email:<input type="text" name="email"><br>
5.​ <input type="submit" value="register">
6.​ </form>

process.jsp

1.​ <jsp:useBean id="u" class="org.sssit.User"></jsp:useBean>


2.​ <jsp:setProperty property="*" name="u"/>
3.​
4.​ Record:<br>
5.​ <jsp:getProperty property="name" name="u"/><br>
6.​ <jsp:getProperty property="password" name="u"/><br>
7.​ <jsp:getProperty property="email" name="u" /><br>

User.java

Page 55
1.​ package org.sssit;
2.​
3.​ public class User {
4.​ private String name,password,email;
5.​ //setters and getters
6.​ }

Reusing Bean in Multiple Jsp Pages


Let's see the simple example, that prints the data of bean object in two jsp pages.

index.jsp

Page 56
Same as above.

User.java

Same as above.

process.jsp

1.​ <jsp:useBean id="u" class="org.sssit.User" scope="session"></jsp:useBean>


2.​ <jsp:setProperty property="*" name="u"/>
3.​
4.​ Record:<br>
5.​ <jsp:getProperty property="name" name="u"/><br>
6.​ <jsp:getProperty property="password" name="u"/><br>
7.​ <jsp:getProperty property="email" name="u" /><br>
8.​
9.​ <a href="second.jsp">Visit Page</a>

second.jsp

1.​ <jsp:useBean id="u" class="org.sssit.User" scope="session"></jsp:useBean>


2.​ Record:<br>
3.​ <jsp:getProperty property="name" name="u"/><br>
4.​ <jsp:getProperty property="password" name="u"/><br>
5.​ <jsp:getProperty property="email" name="u" /><br>

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. For example:

process.jsp

1.​ <jsp:useBean id="u" class="org.sssit.User"></jsp:useBean>


2.​ <%

Page 57
3.​ String name="arjun";
4.​ %>
5.​ <jsp:setProperty property="name" name="u" value="<%=name %>"/>
6.​
7.​ Record:<br>
8.​ <jsp:getProperty property="name" name="u"/><br>

Expression Language (EL) in JSP


1.​ Expression Language (EL) in JSP
2.​ Implicit Objects in Expression Language
3.​ Simple example of Expression Language that prints the name of the user
4.​ Example of Expression Language that prints the value set in the session scope
5.​ Precedence of Operators in EL
6.​ Reserve words in EL

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.

Syntax for Expression Language (EL)

1.​ ${ expression }

Implicit Objects in Expression Language (EL)


There are many implicit objects in the Expression Language. They are as follows:

Implicit Objects Usage

pageScope it maps the given attribute name with the value set in the page scope

Page 58
requestScope it maps the given attribute name with the value set in the request
scope

sessionScope it maps the given attribute name with the value set in the session
scope

applicationScope it maps the given attribute name with the value set in the application
scope

param it maps the request parameter to the single value

paramValues it maps the request parameter to an array of values

header it maps the request header name to the single value

headerValues it maps the request header name to an array of values

cookie it maps the given cookie name to the cookie value

initParam it maps the initialization parameter

pageContext it provides access to many objects request, session etc.

Simple example of Expression Language that prints the


name of the user
In this example, we have created two files index.jsp and process.jsp. 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

1.​ <form action="process.jsp">


2.​ Enter Name:<input type="text" name="name" /><br/><br/>
3.​ <input type="submit" value="go"/>
4.​ </form>

process.jsp

1.​ Welcome, ${ param.name }

Page 59
Example of Expression Language that prints the value set
in the session scope
In this example, we printing the data stored in the session scope using EL. For this
purpose, we have used sessionScope object.

index.jsp

1.​ <h3>welcome to index page</h3>


2.​ <%
3.​ session.setAttribute("user","sonoo");
4.​ %>
5.​
6.​ <a href="process.jsp">visit</a>

process.jsp

1.​ Value is ${ sessionScope.user }

Precedence of Operators in EL
There are many operators that have been provided in the Expression Language.
Their precedence are as follows:

[] .

()

-(unary) not ! empty

* / div % mod

+ - (binary)

< <= > >= lt le gt ge

== != eq ne

Page 60
&& and

|| or

?:

Reserve words in EL
There are many reserve words in the Expression Language. They are as follows:

lt le gt ge

eq ne true false

and or not instanceof

div mod empty null

MVC in JSP
1.​ MVC in JSP
2.​ Example of following MVC in JSP

MVC stands for Model View and Controller. It is adesign 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

Page 61
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.​ <input type="submit" value="login">
5.​ </form>
File: ControllerServlet
1.​ package com.javatpoint;

Page 62
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, HttpServletResponse respon
se)
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("login-success.jsp");
27.​ rd.forward(request, response);
28.​ }
29.​ else{
30.​ RequestDispatcher rd=request.getRequestDispatcher("login-error.jsp");
31.​ rd.forward(request, response);
32.​ }
33.​
34.​ }
35.​
36.​ @Override
37.​ protected void doGet(HttpServletRequest req, HttpServletResponse resp)
38.​ throws ServletException, IOException {
39.​ doPost(req, resp);
40.​ }
41.​}
File: LoginBean.java
1.​ package com.javatpoint;

Page 63
2.​ public class LoginBean {
3.​ private String name,password;
4.​
5.​ public String getName() {
6.​ return name;
7.​ }
8.​ public void setName(String name) {
9.​ this.name = name;
10.​}
11.​public String getPassword() {
12.​ return password;
13.​}
14.​public void setPassword(String password) {
15.​ this.password = password;
16.​}
17.​public boolean validate(){
18.​ if(password.equals("admin")){
19.​ return true;
20.​ }
21.​ else{
22.​ return false;
23.​ }
24.​}
25.​}
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"

Page 64
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>

Page 65
JSTL (JSP Standard Tag Library)
1.​ JSTL
2.​ JSTL Core Tags

Page 66
The JSP Standard Tag Library (JSTL) represents a set of tags 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.

There JSTL mainly provides 5 types of tags:

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
ishttp://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


tags formatting, number and date formatting etc. The url for the
internationalization tags
ishttp://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.

Page 67
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.

Syntax for defining core tags

1.​ <%@ 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.

Example of c:catch
Let's see the simple example of c:catch.

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ <c:catch>
3.​ int a=10/0;
4.​ </c:catch>

c:out
It is just like JSP expression tag but it is used for expression. It renders data to the
page.

Example of c:out

Page 68
Let's see the simple example of c:out.

index.jsp

1.​ <form action="process.jsp" method="post">


2.​ FirstName:<input type="text" name="fname"/><br/>
3.​ LastName:<input type="text" name="lname"/><br/>
4.​ <input type="submit" value="submit"/>
5.​ </form>
process.jsp

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ First Name:<c:out value="${param.fname}"></c:out><br/>
3.​ 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.

Example of c:import
Let's see the simple example of c:import to display the content of other site.

index.jsp

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ <h1>ABC.com</h1>
3.​ <hr/>
4.​ <c:import url="http://www.javatpoint.com"></c:import>

Example of c:import to display the source code


Let's see the simple example of c:import to display the source code of other site.

index.jsp

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ <h1>ABC.com</h1>

Page 69
3.​ <hr/>
4.​ <c:import var="data" url="http://www.javatpoint.com"></c:import>
5.​
6.​ <h2>Data is:</h2>
7.​ <c:out value="${data}"></c:out>

c:forEach
It repeats the nested body content for fixed number of times or over collection.

Example of c:forEach
Let's see the simple example of c:forEach.

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ <c:forEach var="number" begin="5" end="10">
3.​ <c:out value="${number}"></c:out>
4.​ </c:forEach>
download this example

c:if
It tests the condition.

Example of c:if
Let's see the simple example of c:if.

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ <c:set var="number" value="${200}">
3.​ <c:if test="${number<500}">
4.​ <c:out value="number is less than 500"></c:out>
5.​ </c:if>

c:redirect

Page 70
It redirects the request to the given url.

1.​ <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>


2.​ <c:redirect url="http://www.javatpoint.com"></c:redirect>

Custom Tags in JSP


1.​ Custom Tags in JSP
2.​ Advantages of Custom Tags
3.​ Syntax to use custom tag
4.​ JSP Custom Tag API
1.​ JspTag interface
2.​ Tag interface
3.​ IteratorTag interface
4.​ TagSupport class

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.

Advantages of Custom Tags

The key advantages of Custom tags are as follows:

1.​ Eliminates the need of srciptlet tag The custom tags eliminates the need
of scriptlet tag which is considered bad programming approach in JSP.
2.​ Separation of business logic from JSP The custom tags separate the
business logic from the JSP page so that it may be easy to maintain.
3.​ Reusability The custom tags makes the possibility to reuse the same
business logic again and again.

Syntax to use custom tag

There are two ways to use the custom tag. They are given below:

1.​ <prefix:tagname attr1=value1....attrn=valuen />


1.​ <prefix:tagname attr1=value1....attrn=valuen >
2.​ body code

Page 71
3.​ </prefix:tagname>

JSP Custom Tag API


The javax.servlet.jsp.tagext package contains classes and interfaces for JSP custom
tag API. The JspTag is the root interface in the Custom Tag hierarchy.

JspTag interface
The JspTag is the root interface for all the interfaces and classes used in custom
tag. It is a marker interface.

Page 72
Tag interface
The Tag interface is the sub interface of JspTag interface. It provides methods to
perform action at the start and end of the tag.

Fields of Tag interface

There are four fields defined in the Tag interface. They are:

Field Name Description

public static int it evaluates the body content.


EVAL_BODY_INCLUDE

public static int EVAL_PAGE it evaluates the JSP page content after the
custom tag.

public static int SKIP_BODY it skips the body content of the tag.

public static int SKIP_PAGE it skips the JSP page content after the custom
tag.

Methods of Tag interface

The methods of the Tag interface are as follows:

Method Name Description

public void it sets the given PageContext object.


setPageContext(PageContext pc)

public void setParent(Tag t) it sets the parent of the tag handler.

public Tag getParent() it returns the parent tag handler object.

public int doStartTag()throws it is invoked by the JSP page implementation


JspException object. The JSP programmer should override this
method and define the business logic to be
performed at the start of the tag.

Page 73
public int doEndTag()throws it is invoked by the JSP page implementation
JspException object. The JSP programmer should override this
method and define the business logic to be
performed at the end of the tag.

public void release() it is invoked by the JSP page implementation object


to release the state.

IterationTag interface
The IterationTag interface is the sub interface of the Tag interface. It provides an
additional method to reevaluate the body.

Field of IterationTag interface

There is only one field defined in the IterationTag interface.

●​ public static int EVAL_BODY_AGAIN it reevaluates the body content.

Method of Tag interface

There is only one method defined in the IterationTag interface.

●​ public int doAfterBody()throws JspException it is invoked by the JSP


page implementation object after the evaluation of the body. If this method
returns EVAL_BODY_INCLUDE, body content will be reevaluated, if it returns
SKIP_BODY, no more body cotent will be evaluated.

TagSupport class
The TagSupport class implements the IterationTag interface. It acts as the base
class for new Tag Handlers. It provides some additional methods also.

Page 74
Understanding Flow and Example of JSP Custom Tag

There is given two simple examples of JSP custom tag. One example of JSP custom
tag, performs action at the start of the tag and second example performs action at
the start and end of the tag.

Attributes in Custom Tag

Here, we will learn how we can define attributes for the custom tag.

Iteration using Custom Tag

In this example, we are iterating the body content of the custom tag.

Custom URI in Custom Tag

We may also refer the TLD file by using the URI. Here we will learn how can we use
custom URI.

Example of JSP Custom Tag


1.​ Example of JSP Custom Tag
1.​ Create the Tag handler class
2.​ Create the TLD file
3.​ Create the JSP file

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, we need to follow following steps:

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

Page 75
Understanding flow of custom tag in jsp

1) Create the Tag handler class

To create the Tag Handler, we are inheriting the TagSupport class and overriding
its methoddoStartTag().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.

File: MyTagHandler.java
1.​ package com.javatpoint.sonoo;
2.​ import java.util.Calendar;
3.​ import javax.servlet.jsp.JspException;
4.​ import javax.servlet.jsp.JspWriter;
5.​ import javax.servlet.jsp.tagext.TagSupport;
6.​ public class MyTagHandler extends TagSupport{
7.​
8.​ public int doStartTag() throws JspException {
9.​ JspWriter out=pageContext.getOut();//returns the instance of JspWriter
10.​ try{
11.​ out.print(Calendar.getInstance().getTime());//printing date and time using JspW
riter
12.​ }catch(Exception e){System.out.println(e);}
13.​ return SKIP_BODY;//will not evaluate the body content of the tag
14.​}
15.​}

Page 76
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.

File: mytags.tld
1.​
<?xml version="1.0" encoding="ISO-8859-1" ?>
2.​
<!DOCTYPE taglib
3.​ PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4.​ "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
5.​
6.​ <taglib>
7.​
8.​ <tlib-version>1.0</tlib-version>
9.​ <jsp-version>1.2</jsp-version>
10.​ <short-name>simple</short-name>
11.​ <uri>http://tomcat.apache.org/example-taglib</uri>
12.​
13.​<tag>
14.​<name>today</name>
15.​<tag-class>com.javatpoint.sonoo.MyTagHandler</tag-class>
16.​</tag>
17.​</taglib>

3) Create the JSP file

Let's use the tag in our 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. We will
learn about uri later.

It uses taglib directive to use the tags defined in the tld file.

File: index.jsp
1.​ <%@ taglib uri="WEB-INF/mytags.tld" prefix="m" %>
2.​ Current Date and Time is: <m:today/>

download this example

Output

Page 77
Attributes in JSP Custom Tag
1.​ Attributes in JSP Custom Tag
2.​ Example to use attribute in JSP Custom Tag

There can be defined too many attributes for any custom tag. To define the
attribute, you need to perform two tasks:

●​ Define the property in the TagHandler class with the attribute name and
define the setter method
●​ define the attribute element inside the tag element in the TLD file

Example to use attribute in JSP Custom Tag


In this example, we are going to use the cube tag which return the cube of any
given number. Here, we are defining the number attribute for the cube tag. We are
using the three file here:

Page 78
●​ index.jsp
●​ CubeNumber.java
●​ mytags.tld

index.jsp
1.​ <%@ taglib uri="WEB-INF/mytags.tld" prefix="m" %>
2.​
3.​ Cube of 4 is: <m:cube number="4"></m:cube>
CubeNumber.java
1.​ package com.javatpoint.taghandler;
2.​
3.​ import javax.servlet.jsp.JspException;
4.​ import javax.servlet.jsp.JspWriter;
5.​ import javax.servlet.jsp.tagext.TagSupport;
6.​
7.​ public class CubeNumber extends TagSupport{
8.​ private int number;
9.​
10.​public void setNumber(int number) {
11.​ this.number = number;
12.​}
13.​
14.​public int doStartTag() throws JspException {
15.​ JspWriter out=pageContext.getOut();
16.​ try{
17.​ out.print(number*number*number);
18.​ }catch(Exception e){e.printStackTrace();}
19.​
20.​ return SKIP_BODY;
21.​}
22.​}
mytags.tld
1.​ <?xml version="1.0" encoding="ISO-8859-1" ?>
2.​ <!DOCTYPE taglib
3.​ PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4.​ "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
5.​
6.​ <taglib>
7.​ <tlib-version>1.0</tlib-version>
8.​ <jsp-version>1.2</jsp-version>
9.​ <short-name>simple</short-name>
10.​ <uri>http://tomcat.apache.org/example-taglib</uri>

Page 79
11.​ <description>A simple tab library for the examples</description>
12.​
13.​ <tag>
14.​ <name>cube</name>
15.​ <tag-class>com.javatpoint.taghandler.CubeNumber</tag-class>
16.​ <attribute>
17.​ <name>number</name>
18.​ <required>true</required>
19.​ </attribute>
20.​ </tag>
21.​</taglib>

Iteration using JSP Custom Tag


1.​ Iteration using JSP Custom Tag
2.​ Example of Iteration using JSP Custom Tag

We can iterate the body content of any tag using the doAfterBody() method
of IterationTag interface.

Here we are going to use the TagSupport class which implements the IterationTag
interface. For iterating the body content, we need to use
the EVAL_BODY_AGAIN constant in the doAfterBody() method.

Example of Iteration using JSP Custom Tag


In this example, we are going to use the attribute in the custom tag, which returns
the power of any given number. We have created three files here

●​ index.jsp
●​ PowerNumber.java
●​ mytags.tld

index.jsp
1.​ <%@ taglib uri="WEB-INF/mytags.tld" prefix="m" %>
2.​
3.​ 3 ^ 5 = <m:power number="3" power="5">
4.​ body
5.​ </m:power>

Page 80
PowerNumber.java
1.​ package com.javatpoint.taghandler;
2.​
3.​ import javax.servlet.jsp.JspException;
4.​ import javax.servlet.jsp.JspWriter;
5.​ import javax.servlet.jsp.tagext.TagSupport;
6.​
7.​ public class PowerNumber extends TagSupport{
8.​ private int number;
9.​ private int power;
10.​private static int counter;
11.​private static int result=1;
12.​
13.​public void setPower(int power) {
14.​ this.power = power;
15.​}
16.​
17.​public void setNumber(int number) {
18.​ this.number = number;
19.​}
20.​
21.​public int doStartTag() throws JspException {
22.​ return EVAL_BODY_INCLUDE;
23.​}
24.​
25.​public int doAfterBody() {
26.​ counter++;
27.​ result *= number;
28.​ if (counter==power)
29.​ return SKIP_BODY;
30.​ else
31.​ return EVAL_BODY_AGAIN;
32.​ }
33.​
34.​public int doEndTag() throws JspException {
35.​ JspWriter out=pageContext.getOut();
36.​ try{
37.​ out.print(result);
38.​ }catch(Exception e){e.printStackTrace();}
39.​
40.​ return EVAL_PAGE;
41.​}
42.​}

Page 81
mytags.tld
1.​<?xml version="1.0" encoding="ISO-8859-1" ?>
2.​<!DOCTYPE taglib
3.​ PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4.​ "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
5.​
6.​ <taglib>
7.​ <tlib-version>1.0</tlib-version>
8.​ <jsp-version>1.2</jsp-version>
9.​ <short-name>simple</short-name>
10.​ <uri>http://tomcat.apache.org/example-taglib</uri>
11.​ <description>A simple tab library for the examples</description>
12.​
13.​ <tag>
14.​ <name>power</name>
15.​ <tag-class>com.javatpoint.taghandler.PowerNumber</tag-class>
16.​
17.​ <attribute>
18.​ <name>number</name>
19.​ <required>true</required>
20.​ </attribute>
21.​
22.​ <attribute>
23.​ <name>power</name>
24.​ <required>true</required>
25.​ </attribute>
26.​
27.​ </tag>
28.​</taglib>

Looping using Iteration Tag (creating tag for loop)


Let's create a loop tag that iterates the body content of this tag.

File: index.jsp
1.​ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w
3.org/TR/html4/loose.dtd">
2.​ <html>
3.​ <head>
4.​ <title>Insert title here</title>

Page 82
5.​ </head>
6.​ <body>
7.​
8.​ <%@taglib prefix="m" uri="sssuri" %>
9.​ <m:loop end="5" start="1">
10.​<p>My Name is khan</p>
11.​</m:loop>
12.​
13.​</body>
14.​</html>
File: mytags.tld
1.​ <?xml version="1.0" encoding="ISO-8859-1" ?>
2.​ <!DOCTYPE taglib
3.​ PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4.​ "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
5.​ <taglib>
6.​ <tlib-version>1.0</tlib-version>
7.​ <jsp-version>1.2</jsp-version>
8.​ <short-name>abc</short-name>
9.​
10.​ <uri>sssuri</uri>
11.​ <tag>
12.​ <name>loop</name>
13.​ <tag-class>com.javatpoint.customtag.Loop</tag-class>
14.​
15.​ <attribute>
16.​ <name>start</name>
17.​ <required>true</required>
18.​ </attribute>
19.​
20.​ <attribute>
21.​ <name>end</name>
22.​ <required>true</required>
23.​ </attribute>
24.​ </tag>
25.​
26.​</taglib>
File: Loop.java
1.​ package com.javatpoint.customtag;
2.​ import javax.servlet.jsp.JspException;
3.​ import javax.servlet.jsp.tagext.TagSupport;
4.​
5.​ public class Loop extends TagSupport{

Page 83
6.​ private int start=0;
7.​ private int end=0;
8.​
9.​ public void setStart(int start) {
10.​ this.start = start;
11.​ }
12.​ public void setEnd(int end) {
13.​ this.end = end;
14.​ }
15.​
16.​ @Override
17.​ public int doStartTag() throws JspException {
18.​ return EVAL_BODY_INCLUDE;
19.​ }
20.​
21.​ @Override
22.​ public int doAfterBody() throws JspException {
23.​ if(start<end){
24.​ start++;
25.​ return EVAL_BODY_AGAIN;
26.​ }else{
27.​ return SKIP_BODY;
28.​ }
29.​
30.​ }
31.​
32.​
33.​}
File: web.xml
1.​ <?xml version="1.0" encoding="UTF-8"?>
2.​ <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="htt
p://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/
web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://
java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
3.​
4.​ <jsp-config>
5.​ <taglib>
6.​ <taglib-uri>sssuri</taglib-uri>
7.​ <taglib-location>/WEB-INF/mytags.tld</taglib-location>
8.​ </taglib>
9.​ </jsp-config>
10.​
11.​</web-app>

Page 84
Output

Custom URI in JSP Custom Tag


1.​ Custom URI in JSP Custom Tag
2.​ Example to use Custom URI in JSP Custom Tag

We can use the custom URI, to tell the web container about the tld file. In such
case, we need to define the taglib element in the web.xml. The web container gets
the information about the tld file from the web.xml file for the specified URI.

Example to use custom URI in JSP Custom Tag


In this example, we are going to use the custom uri in the JSP file. For this
application, we need to focus on 4 files.

●​ index.jsp
●​ web.xml

Page 85
●​ mytags.tld
●​ PrintDate.java

index.jsp
1.​ <%@ taglib uri="mytags" prefix="m" %>
2.​ Today is: <m:today></m:today>

web.xml
1.​ <?xml version="1.0" encoding="UTF-8"?>
2.​ <!DOCTYPE web-app
3.​ PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
4.​ "http://java.sun.com/dtd/web-app_2_3.dtd">
5.​
6.​ <web-app>
7.​
8.​ <jsp-config>
9.​ <taglib>
10.​<taglib-uri>mytags</taglib-uri>
11.​<taglib-location>/WEB-INF/mytags.tld</taglib-location>
12.​</taglib>
13.​</jsp-config>
14.​
15.​</web-app>

mytags.tld
1.​<?xml version="1.0" encoding="ISO-8859-1" ?>
2.​<!DOCTYPE taglib
3.​ PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4.​ "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
5.​
6.​ <taglib>
7.​ <tlib-version>1.0</tlib-version>
8.​ <jsp-version>1.2</jsp-version>
9.​ <short-name>simple</short-name>
10.​ <uri>mytags</uri>
11.​ <description>A simple tab library for the examples</description>
12.​
13.​ <tag>
14.​ <name>today</name>
15.​ <tag-class>com.javatpoint.taghandler.PrintDate</tag-class>
16.​ </tag>
17.​</taglib>

Page 86
PrintDate.java
1.​ package com.javatpoint.taghandler;
2.​
3.​ import javax.servlet.jsp.JspException;
4.​ import javax.servlet.jsp.JspWriter;
5.​ import javax.servlet.jsp.tagext.TagSupport;
6.​
7.​ public class PrintDate extends TagSupport{
8.​
9.​ public int doStartTag() throws JspException {
10.​ JspWriter out=pageContext.getOut();
11.​ try{
12.​ out.print(java.util.Calendar.getInstance().getTime());
13.​ }catch(Exception e){e.printStackTrace();}
14.​
15.​ return SKIP_BODY;
16.​ }
17.​
18.​
19.​}

Registration Form in JSP


1.​ Registration Form in JSP
2.​ Example of Registration Form in JSP

For creating registration form, you must have a table in the database. You can write
the database logic in JSP file, but separating it from the JSP page is better
approach. Here, we are going to use DAO, Factory Method, DTO and Singletion
design patterns. There are many files:

●​ index.jsp for getting the values from the user


●​ User.java, a bean class that have properties and setter and getter methods.
●​ process.jsp, a jsp file that processes the request and calls the methods
●​ Provider.java, an interface that contains many constants like
DRIVER_CLASS, CONNECTION_URL, USERNAME and PASSWORD
●​ ConnectionProvider.java, a class that returns an object of Connection. It
uses the Singleton and factory method design pattern.
●​ RegisterDao.java, a DAO class that is responsible to get access to the
database

Page 87
Example of Registration Form in JSP
In this example, we are using the Oracle10g database to connect with the
database. Let's first create the table in the Oracle database:
1.​ CREATE TABLE "USER432"
2.​ ( "NAME" VARCHAR2(4000),
3.​ "EMAIL" VARCHAR2(4000),
4.​ "PASS" VARCHAR2(4000)
5.​ )
6.​ /

We have created the table named user432 here.

index.jsp

We are having only three fields here, to make the concept clear and simplify the
flow of the application. You can have other fields also like country, hobby etc.
according to your requirement.

1.​ <form action="process.jsp">


2.​ <input type="text" name="uname" value="Name..." onclick="this.value=''"/><br/
>
3.​ <input type="text" name="uemail" value="Email ID..." onclick="this.value=''"/><
br/>
4.​ <input type="password" name="upass" value="Password..." onclick="this.value=''
"/><br/>
5.​ <input type="submit" value="register"/>
6.​ </form>

process.jsp

This jsp file contains all the incoming values to an object of bean class which is
passed as an argument in the register method of the RegisterDao class.

1.​ <%@page import="bean.RegisterDao"%>

Page 88
2.​ <jsp:useBean id="obj" class="bean.User"/>
3.​
4.​ <jsp:setProperty property="*" name="obj"/>
5.​
6.​ <%
7.​ int status=RegisterDao.register(obj);
8.​ if(status>0)
9.​ out.print("You are successfully registered");
10.​
11.​%>

User.java

It is the bean class that have 3 properties uname, uemail and upass with its
setter and getter methods.
1.​ package bean;
2.​
3.​ public class User {
4.​ private String uname,upass,uemail;
5.​
6.​ public String getUname() {
7.​ return uname;
8.​ }
9.​
10.​public void setUname(String uname) {
11.​ this.uname = uname;
12.​}
13.​
14.​public String getUpass() {
15.​ return upass;
16.​}
17.​
18.​public void setUpass(String upass) {
19.​ this.upass = upass;
20.​}
21.​
22.​public String getUemail() {
23.​ return uemail;
24.​}
25.​
26.​public void setUemail(String uemail) {

Page 89
27.​ this.uemail = uemail;
28.​}
29.​
30.​}

Provider.java

This interface contains four constants that can vary from database to database.

1.​ package bean;


2.​
3.​ public interface Provider {
4.​ String DRIVER="oracle.jdbc.driver.OracleDriver";
5.​ String CONNECTION_URL="jdbc:oracle:thin:@localhost:1521:xe";
6.​ String USERNAME="system";
7.​ String PASSWORD="oracle";
8.​
9.​ }

ConnectionProvider.java

This class is responsible to return the object of Connection. Here, driver class is
loaded only once and connection object gets memory only once.

1.​ package bean;


2.​ import java.sql.*;
3.​ import static bean.Provider.*;
4.​
5.​ public class ConnectionProvider {
6.​ private static Connection con=null;
7.​ static{
8.​ try{
9.​ Class.forName(DRIVER);
10.​con=DriverManager.getConnection(CONNECTION_URL,USERNAME,PASSWORD);
11.​}catch(Exception e){}
12.​}
13.​
14.​public static Connection getCon(){
15.​ return con;

Page 90
16.​}
17.​
18.​}

RegisterDao.java

This class inserts the values of the bean component into the database.

1.​ package bean;


2.​
3.​ import java.sql.*;
4.​
5.​ public class RegisterDao {
6.​
7.​ public static int register(User u){
8.​ int status=0;
9.​ try{
10.​Connection con=ConnectionProvider.getCon();
11.​PreparedStatement ps=con.prepareStatement("insert into user432 values(?,?,?)");

12.​ps.setString(1,u.getUname());
13.​ps.setString(2,u.getUemail());
14.​ps.setString(3,u.getUpass());
15.​
16.​status=ps.executeUpdate();
17.​}catch(Exception e){}
18.​
19.​return status;
20.​}
21.​
22.​}

Login and Logout Example in JSP


1.​ Login and Logout Example in JSP
2.​ Example of Login Form in JSP

Page 91
In this example of creating login form, we have used the DAO (Data Access
Object), Factory method and DTO (Data Transfer Object) design patterns. There
are many files:
●​ index.jsp it provides three links for login, logout and profile
●​ login.jsp for getting the values from the user
●​ loginprocess.jsp, a jsp file that processes the request and calls the
methods.
●​ LoginBean.java, a bean class that have properties and setter and getter
methods.
●​ Provider.java, an interface that contains many constants like
DRIVER_CLASS, CONNECTION_URL, USERNAME and PASSWORD
●​ ConnectionProvider.java, a class that is responsible to return the object
of Connection. It uses the Singleton and factory method design pattern.
●​ LoginDao.java, a DAO class that verifies the emailId and password from
the database.
●​ logout.jsp it invalidates the session.
●​ profile.jsp it provides simple message if user is logged in, otherwise
forwards the request to the login.jsp page.

In this example, we are using the Oracle10g database to match the emailId and
password with the database. The table name is user432 which have many fields like
name, email, pass etc. You may use this query to create the table:

1.​ CREATE TABLE "USER432"


2.​ ( "NAME" VARCHAR2(4000),
3.​ "EMAIL" VARCHAR2(4000),
4.​ "PASS" VARCHAR2(4000)
5.​ )
6.​ /

We assume that there are many records in this table.

index.jsp

It simply provides three links for login, logout and profile.

1.​ <a href="login.jsp">login</a>|

Page 92
2.​ <a href="logout.jsp">logout</a>|
3.​ <a href="profile.jsp">profile</a>

login.jsp

This file creates a login form for two input fields name and password. It is the
simple login form, you can change it for better look and feel. We are focusing on
the concept only.

1.​ <%@ include file="index.jsp" %>


2.​ <hr/>
3.​
4.​ <h3>Login Form</h3>
5.​ <%
6.​ String profile_msg=(String)request.getAttribute("profile_msg");
7.​ if(profile_msg!=null){
8.​ out.print(profile_msg);
9.​ }
10.​String login_msg=(String)request.getAttribute("login_msg");
11.​if(login_msg!=null){
12.​out.print(login_msg);
13.​}
14.​ %>
15.​ <br/>
16.​<form action="loginprocess.jsp" method="post">
17.​Name:<input type="text" name="name"/><br/><br/>
18.​Password:<input type="password" name="password"/><br/><br/>
19.​<input type="submit" value="login"/>"
20.​</form>

loginprocess.jsp

This jsp file contains all the incoming values to an object of bean class which is
passed as an argument in the validate method of the LoginDao class. If emailid and
password is correct, it displays a message you are successfully logged in! and
maintains the session so that we may recognize the user.

1.​ <%@page import="bean.LoginDao"%>


2.​ <jsp:useBean id="obj" class="bean.LoginBean"/>
3.​

Page 93
4.​ <jsp:setProperty property="*" name="obj"/>
5.​
6.​ <%
7.​ boolean status=LoginDao.validate(obj);
8.​ if(status){
9.​ out.println("You r successfully logged in");
10.​session.setAttribute("session","TRUE");
11.​}
12.​else
13.​{
14.​out.print("Sorry, email or password error");
15.​%>
16.​<jsp:include page="index.jsp"></jsp:include>
17.​<%
18.​}
19.​%>

LoginBean.java

It is the bean class that have 2 properties email and pass with its setter and getter
methods.

1.​ package bean;


2.​
3.​ public class LoginBean {
4.​ private String email,pass;
5.​
6.​ public String getEmail() {
7.​ return email;
8.​ }
9.​
10.​public void setEmail(String email) {
11.​ this.email = email;
12.​}
13.​
14.​public String getPass() {
15.​ return pass;
16.​}
17.​
18.​public void setPass(String pass) {
19.​ this.pass = pass;

Page 94
20.​}
21.​
22.​
23.​}

Provider.java

This interface contains four constants that may differ from database to database.
1.​ package bean;
2.​
3.​ public interface Provider {
4.​ String DRIVER="oracle.jdbc.driver.OracleDriver";
5.​ String CONNECTION_URL="jdbc:oracle:thin:@localhost:1521:xe";
6.​ String USERNAME="system";
7.​ String PASSWORD="oracle";
8.​
9.​ }

ConnectionProvider.java

This class provides a factory method that returns the object of Connection. Here,
driver class is loaded only once and connection object gets memory only once
because it is static.

1.​ package bean;


2.​ import java.sql.*;
3.​ import static bean.Provider.*;
4.​
5.​ public class ConnectionProvider {
6.​ private static Connection con=null;
7.​ static{
8.​ try{
9.​ Class.forName(DRIVER);
10.​con=DriverManager.getConnection(CONNECTION_URL,USERNAME,PASSWORD);
11.​}catch(Exception e){}
12.​}
13.​
14.​public static Connection getCon(){
15.​ return con;

Page 95
16.​}
17.​
18.​}

LoginDao.java

This class varifies the emailid and password.

1.​ package bean;


2.​ import java.sql.*;
3.​ public class LoginDao {
4.​
5.​ public static boolean validate(LoginBean bean){
6.​ boolean status=false;
7.​ try{
8.​ Connection con=ConnectionProvider.getCon();
9.​
10.​PreparedStatement ps=con.prepareStatement(
11.​ "select * from user432 where email=? and pass=?");
12.​
13.​ps.setString(1,bean.getEmail());
14.​ps.setString(2, bean.getPass());
15.​
16.​ResultSet rs=ps.executeQuery();
17.​status=rs.next();
18.​
19.​}catch(Exception e){}
20.​
21.​return status;
22.​
23.​}
24.​}

​ Uploading file to the server using JSP


1.​ Uploading file to the server using JSP
2.​ MultipartRequest class
3.​ Constructors of MultipartRequest class

Page 96
4.​ Example of File Upload in JSP

There are many ways to upload the file to the server. One of the way is by the
MultipartRequest class. For using this class you need to have the cos.jar file. In this
example, we are providing the cos.jar file alongwith the code.

MultipartRequest class
It is a utility class to handle the multipart/form-data request. There are many
constructors defined in the MultipartRequest class.

Commonly used Constructors of MultipartRequest class

●​ MultipartRequest(HttpServletRequest request, String


saveDirectory) uploads the file upto 1MB.
●​ MultipartRequest(HttpServletRequest request, String saveDirectory,
int maxPostSize) uploads the file upto specified post size.
●​ MultipartRequest(HttpServletRequest request, String saveDirectory,
int maxPostSize, String encoding) uploads the file upto specified post size
with given encoding.

Example of File Upload in JSP


In this example, we are creating two files only, index.jsp and fileupload.jsp.

index.jsp

To upload the file to the server, there are two requirements:

1.​ You must use the post request.


2.​ encodeType should be multipart/form-data that gives information to the
server that you are going to upload the file.

1.​ <form action="upload.jsp" method="post" enctype="multipart/form-data">


2.​ Select File:<input type="file" name="fname"/><br/>
3.​ <input type="image" src="MainUpload.png"/>
4.​ </form>

Page 97
upload.jsp

We are uploading the incoming file to the location d:/new, you can specify your
location here.

1.​ <%@ page import="com.oreilly.servlet.MultipartRequest" %>


2.​ <%
3.​ MultipartRequest m = new MultipartRequest(request, "d:/new");
4.​ out.print("successfully uploaded");
5.​
6.​ %>

If size of the file is greater than 1MB, you should specify the post size.

Example of Downloading file from the server using


JSP
In this example, we are going to download the jsp file. But you may download any
file. For downloading the file from the server, you should specify the content type
named APPLICATION/OCTET-STREAM.

index.jsp

This file provides a link to download the jsp file.

1.​ <a href="download.jsp">download the jsp file</a>

download.jsp

In this example, we are downloading the file home.jsp which is located in the e:
drive. You may change this location accordingly.

1.​ <%
2.​ String filename = "home.jsp";

Page 98
3.​ String filepath = "e:\\";
4.​ response.setContentType("APPLICATION/OCTET-STREAM");
5.​ response.setHeader("Content-Disposition","attachment; filename=\"" + filename
+ "\"");
6.​
7.​ java.io.FileInputStream fileInputStream=new java.io.FileInputStream(filepath + fi
lename);
8.​
9.​ int i;
10.​ while ((i=fileInputStream.read()) != -1) {
11.​ out.write(i);
12.​ }
13.​ fileInputStream.close();
14.​%>

Page 99

You might also like