jsp scriptlet tag
DESCRIPTION
mechTRANSCRIPT
JSP DOCUMENTS
SHARAN K P Page 1
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
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: <% java source code %>
Simple Example of JSP scriptlet tag
In this example, we are displaying a welcome message. <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.
index.html
<html> <body> <form action="welcome.jsp"> <input type="text" name="uname">
JSP DOCUMENTS
SHARAN K P Page 2
<input type="submit" value="go"><br/>
</form> </body> </html>
welcome.jsp
<html> <body> <%
String name=request.getParameter("uname"); out.print("welcome "+name); %> </form> </body> </html>
next>>
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
<%= 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
JSP DOCUMENTS
SHARAN K P Page 3
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.
index.html
<html> <body> <form action="welcome.jsp">
<input type="text" name="uname"><br/> <input type="submit" value="go"> </form> </body>
</html>
welcome.jsp
<html> <body> <%= "Welcome "+request.getParameter("uname") %> </form>
</body> </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
JSP DOCUMENTS
SHARAN K P Page 4
get memory at each request.
Syntax of JSP declaration tag
The syntax of the declaration tag is as follows:
<%! statement %>
What is the difference between the jsp scriptlet tag and jsp declaration tag ?
The jsp scriptlet tag can only declare variables not methods whereas jsp declaration tag can declare variables as well as methods.
The declaration of scriptlet tag is placed inside the _jspService() method whereas the declaration of jsp declaration tag is placed 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
<html> <body>
<%! int data=50; %> <%= "Value of the variable is:"+data %> </body> </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
<html> <body> <%!
JSP DOCUMENTS
SHARAN K P Page 5
int cube(int n){
return n*n*n*; } %>
<%= "Cube of 3 is:"+cube(3) %> </body> </html>
JSP Implicit Objects
1. JSP Implicit Objects
2. out implicit object
3. Example of out implicit object
There are 9 implicit objects available for the JSP page. The Auto Generated Servlet contains many objects like out, request, config, session, application etc. The 9 implicit objects are as follows:
Object Type
out JspWriter
request HttpServletRequest
response HttpServletResponse
config ServletConfig
application ServletContext
session HttpSession
pageContext PageContext
page Object
exception Throwable
1) 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: PrintWriter out=response.getWriter();
But in JSP, you don't need to write this code.
Example of out implicit object
JSP DOCUMENTS
SHARAN K P Page 6
In this example we are simply displaying date and time.
index.jsp
<html> <body> <% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %> </body> </html>
2) request implicit object
In JSP, request is an implicit object of type HttpServletRequest. Let's see the simple example of
request implicit object where we are printing the name of the user with welcome message.
Example of request implicit object
index.html
<html> <body> <form action="welcome.jsp"> <input type="text" name="uname"> <input type="submit" value="go"><br/>
</form> </body> </html>
welcome.jsp
<html> <body> <% String name=request.getParameter("uname"); out.print("welcome "+name); %> </body> </html>
next>>
3) response implicit object
In JSP, response is an implicit object of type HttpServletResponse. Let's see the example of response implicit object where we are redirecting the request to the Google.
Example of response implicit object
index.html
<html> <body>
JSP DOCUMENTS
SHARAN K P Page 7
<form action="welcome.jsp">
<input type="text" name="uname"> <input type="submit" value="go"><br/> </form>
</body> </html>
welcome.jsp <html> <body> <% response.sendRedirect("http://www.google.com");
%>
</body>
</html> next>>
4) config implicit object
In JSP, config is an implicit object of type ServletConfig. This object can be used to get
configuration information for a particular JSP page.This variable information can be used for one jsp page only.
Example of config implicit object:
index.html <html> <body>
<form action="welcome"> <input type="text" name="uname"> <input type="submit" value="go"><br/> </form> </body> </html>
web.xml file <web-app>
<servlet> <servlet-name>sonoojaiswal</servlet-name>
<jsp-file>/welcome.jsp</jsp-file> <init-param> <param-name>dname</param-name> <param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>
</init-param> </servlet> <servlet-mapping> <servlet-name>sonoojaiswal</servlet-name>
<url-pattern>/welcome</url-pattern>
JSP DOCUMENTS
SHARAN K P Page 8
</servlet-mapping>
</web-app>
welcome.jsp <html> <body>
<% out.print("Welcome "+request.getParameter("uname")); String driver=config.getInitParameter("dname"); out.print("driver name is="+driver);
%>
</body> </html>
next>>
5) application implicit object
In JSP, application is an implicit object of type ServletContext.This object can be used to get configuration information from configuaration file(web.xml). This variable information can be used for all jsp pages.
Example of application implicit object:
index.html <html>
<body> <form action="welcome"> <input type="text" name="uname"> <input type="submit" value="go"><br/> </form> </body> </html>
web.xml file <web-app>
<servlet> <servlet-name>sonoojaiswal</servlet-name> <jsp-file>/welcome.jsp</servlet-class>
</servlet> <servlet-mapping>
<servlet-name>sonoojaiswal</servlet-name> <url-pattern>/welcome</url-pattern> </servlet-mapping> <context-param> <param-name>dname</param-name>
<param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value> </context-param>
JSP DOCUMENTS
SHARAN K P Page 9
</web-app>
welcome.jsp <html> <body> <%
out.print("Welcome "+request.getParameter("uname")); String driver=application.getInitParameter("dname"); out.print("driver name is="+driver); %>
</body> </html>
next>>
6) session implicit object
In JSP, session is an implicit object of type HttpSession.The Java developer can use this object to set,get or remove attribute or to get session information.
Example of session implicit object
index.html
<html>
<body> <form action="welcome.jsp"> <input type="text" name="uname"> <input type="submit" value="go"><br/> </form>
</body> </html>
welcome.jsp
<html>
<body> <% String name=request.getParameter("uname");
out.print("Welcome "+name); session.setAttribute("user",name);
<a href="second.jsp">second jsp page</a> %> </body> </html>
JSP DOCUMENTS
SHARAN K P Page 10
second.jsp
<html> <body> <% String name=(String)session.getAttribute("user");
out.print("Hello "+name); %> </body> </html>
7) pageContext implicit object
In JSP, pageContext is an implicit object of type PageContext class.The pageContext object can be used to set,get or remove attribute from one of the following scopes:
page
request
session
application
In JSP, page scope is the default scope.
Example of pageContext implicit object
index.html
<html> <body> <form action="welcome.jsp"> <input type="text" name="uname"> <input type="submit" value="go"><br/> </form>
</body> </html>
welcome.jsp
<html> <body>
<% String name=request.getParameter("uname"); out.print("Welcome "+name); pageContext.setAttribute("user",name,PageContext.SESSION_SCOPE);
JSP DOCUMENTS
SHARAN K P Page 11
<a href="second.jsp">second jsp page</a>
%> </body> </html>
second.jsp
<html> <body>
<% String name=(String)pageContext.getAttribute("user",PageContext.SESSION_SCOPE); out.print("Hello "+name);
%>
</body>
</html> next>>
8) page implicit object:
In JSP, page is an implicit object of type Object class.This object is assigned to the reference of auto generated servlet class. It is written as:
Object page=this;
For using this object it must be cast to Servlet type.For example:
<% (HttpServlet)page.log("message"); %>
Since, it is of type Object it is less used because you can use this object directly in jsp.For
example:
<% this.log("message"); %>
next>>
9) exception implicit object
In JSP, exception is an implicit object of type java.lang.Throwable class. This object can be used to print the exception. But it can only be used in error pages.It is better to learn it after page directive. Let's see a simple example:
Example of exception implicit object:
error.jsp
<%@ page isErrorPage="true" %> <html> <body> Sorry following exception occured:<%= exception %> </body>
JSP DOCUMENTS
SHARAN K P Page 12
</html>
To get the full example, click here full example of exception handling in jsp. But, it will be better to learn it after the JSP Directives
next>>
JSP directives
1. JSP directives
1. page directive
2. Attributes of page directive
1. import
2. contentType
3. extends
4. info
5. buffer
6. language
7. isELIgnored
8. isThreadSafe
9. errorPage
10. isErrorPage
The directives are messages that tells the web container how to translate a JSP page into
corresponding servlet.There are three types of directives:
page directive
include directive
taglib directive
Syntax of JSP Directive
<%@ directive attribute="value" %>
JSP page directive
The page directive defines attributes that apply to an entire JSP page.
Syntax of JSP page directive
<%@ page attribute="value" %>
Attributes of JSP page directive
JSP DOCUMENTS
SHARAN K P Page 13
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
<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
<html>
<body> <%@ page contentType=application/msword %> Today is: <%= new java.util.Date() %> </body>
JSP DOCUMENTS
SHARAN K P Page 14
</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
<html> <body> <%@ page info="composed by Sonoo Jaiswal" %> Today is: <%= new java.util.Date() %> </body>
</html> The web container will create a method getServletInfo() in the resulting servlet.For example:
public String getServletInfo() { return "composed by Sonoo Jaiswal"; }
5)buffer
The buffer attribute sets the buffer size in kilobytes to handle output generated by the JSP
page.The default size of the buffer is 8Kb.
Example of buffer attribute
<html> <body> <%@ page buffer="16kb" %> Today is: <%= new java.util.Date() %>
</body> </html>
JSP DOCUMENTS
SHARAN K P Page 15
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.
<%@ 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:
<%@ 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
//index.jsp <html>
<body> <%@ page errorPage="myerrorpage.jsp" %> <%= 100/0 %>
JSP DOCUMENTS
SHARAN K P Page 16
</body> </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
//myerrorpage.jsp
<html> <body> <%@ page isErrorPage="true" %> Sorry an exception occured!<br>
The exception is: <%= exception %> </body> </html>
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
<%@ include file="resourceName" %>
Example of include directive
JSP DOCUMENTS
SHARAN K P Page 17
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> <body> <%@ include file="header.html" %>
Today is: <%= java.util.Calendar.getInstance().getTime() %> </body> </html>
Note: The include directive includes the original content, so the actual page size grows at
runtime.
JSP DOCUMENTS
SHARAN K P Page 18
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
<%@ 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.
<html> <body>
<%@ taglib uri="http://www.javatpoint.com/tags" prefix="mytag" %> <mytag:currentdate> </body>
</html>
</mytag:currentdate>
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
JSP DOCUMENTS
SHARAN K P Page 19
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); %>
error.jsp
<%@ page isErrorPage="true" %>
<h3>Sorry an exception occured!</h3> Exception is: <%= exception %>
Output of this example:
JSP DOCUMENTS
SHARAN K P Page 20
JSP DOCUMENTS
SHARAN K P Page 21
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
JSP DOCUMENTS
SHARAN K P Page 22
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
<web-app> <error-page> <exception-type>java.lang.Exception</exception-type>
<location>/error.jsp</location> </error-page> </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
<web-app> <error-page> <error-code>500</error-code>
<location>/error.jsp</location> </error-page> </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.
<%@ 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);
%>
JSP DOCUMENTS
SHARAN K P Page 23
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
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
<jsp:forward page="relativeURL | <%= expression %>" />
Syntax of jsp:forward action tag with parameter
<jsp:forward page="relativeURL | <%= expression %>">
<jsp:param name="parametername" value="parametervalue | <%=expression%>" /> </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
JSP DOCUMENTS
SHARAN K P Page 24
<html>
<body> <h2>this is index page</h2>
<jsp:forward page="printdate.jsp" /> </body> </html>
printdate.jsp
<html> <body> <% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %> </body> </html>
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
<html> <body>
<h2>this is index page</h2>
<jsp:forward page="printdate.jsp" > <jsp:param name="name" value="javatpoint.com" /> </jsp:forward> </body> </html>
printdate.jsp
<html> <body>
<% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %> <%= request.getParameter("name") %>
</body> </html>
next>>
jsp:include action tag
1. jsp:include action tag
2. Syntax of jsp:include action tag
JSP DOCUMENTS
SHARAN K P Page 25
3. Example of jsp:include action tag without parameter
The jsp:forward action tag is used to include the content of another resource it may be jsp, html or servlet. The jsp include action tag includes the resource at request time so it is better for dynamic pages because there might be changes in future.
Advantage of jsp:include action tag
code reusability
Syntax of jsp:include action tag without parameter
<jsp:include page="relativeURL | <%= expression %>" />
Syntax of jsp:include action tag with parameter
<jsp:include page="relativeURL | <%= expression %>"> <jsp:param name="parametername" value="parametervalue | <%=expression%>" /> </jsp:forward>
Example of jsp:include action tag without parameter
In this example, index.jsp file includes the content of the printdate.jsp file.
index.jsp
<html> <body> <h2>this is index page</h2> <jsp:include page="printdate.jsp" />
<h2>end section of index page</h2> </body> </html>
printdate.jsp
<html> <body>
<% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %> </body> </html>
next>>
Java Bean
JSP DOCUMENTS
SHARAN K P Page 26
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
//Employee.java package mypack; public class Employee implements java.io.Serializable{
private int id; private String name; public Employee(){} public void setId(int id){this.id=id;}
public int getId(){return id;}
public void setName(String name){this.name=name;} public String getName(){return name;}
}
How to access the java bean class?
To access the java bean class, we should use getter and setter methods.
package mypack; public class Test{ public static void main(String args[]){
Employee e=new Employee();//object is created e.setName("Arjun");//setting value to the object System.out.println(e.getName());
}}
Note: There are two ways to provide values to the object, one way is by constructor and
second is by setter method.
JSP DOCUMENTS
SHARAN K P Page 27
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
<jsp:useBean id= "instanceName" scope= "page | request | session | application" class= "packageName.className" type= "packageName.className" beanName="packageName.className | <%= expression >" > </jsp:useBean>
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.
JSP DOCUMENTS
SHARAN K P Page 28
Calculator.java (a simple Bean class)
package com.javatpoint; public class Calculator{ public int cube(int n){return n*n*n;} }
index.jsp file
<jsp:useBean id="obj" class="com.javatpoint.Calculator"/>
<% int m=obj.cube(5);
out.print("cube of 5 is "+m); %>
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
The setProperty and getProperty action tags are used for developing web application with Java
Bean. In web devlopment, bean class is mostly used because it is a reusable software
JSP DOCUMENTS
SHARAN K P Page 29
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
<jsp:setProperty name="instanceOfBean" property= "*" | property="propertyName" param="parameterName" | property="propertyName" value="{ string | <%= expression %>}" />
Example of jsp:setProperty action tag if you have to set all the values of incoming request in the bean
<jsp:setProperty name="bean" property="*" />
Example of jsp:setProperty action tag if you have to set value of the incoming specific property
<jsp:setProperty name="bean" property="username" />
Example of jsp:setProperty action tag if you have to set a specific value in the property
<jsp:setProperty name="bean" property="username" value="Kumar" />
jsp:getProperty action tag The jsp:getProperty action tag returns the value of the property.
Syntax of jsp:getProperty action tag
<jsp:getProperty name="instanceOfBean" property="propertyName" />
Simple example of jsp:getProperty action tag
<jsp:getProperty name="obj" property="name" />
Example of bean development in JSP
JSP DOCUMENTS
SHARAN K P Page 30
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
<form action="welcome.jsp"/> Enter Name:<input type="text" name="name"/>
</form>
welcome.jsp
<jsp:useBean id="obj" class="com.javatpoint.User" /> <jsp:setProperty name="obj" property="*" />
Welcome, <jsp:getProperty name="obj" property="name" />
User.java
package com.javatpoint; public class User{ private String name;
public void setName(String name){ this.name=name; } public String getName(){
return name;
} }
JSP DOCUMENTS
SHARAN K P Page 31
Displaying applet in JSP (jsp:plugin action tag)
1. Displaying applet in JSP
2. Syntax of jsp:plugin action tag
3. Example of displaying applet in JSP
The jsp:plugin action tag is used to embed applet in the jsp file. The jsp:plugin action tag
downloads plugin at client side to execute an applet or bean.
Syntax of jsp:plugin action tag
<jsp:plugin type= "applet | bean" code= "nameOfClassFile" codebase= "directoryNameOfClassFile" </jsp:useBean>
Example of displaying applet in JSP
In this example, we are simply displaying applet in jsp using the jsp:plugin tag. You must have
MouseDrag.class file (an applet class file) in the current folder where jsp file resides. You may
simply download this program that contains index.jsp, MouseDrag.java and MouseDrag.class
files to run this application.
index.jsp
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Mouse Drag</title> </head> <body bgcolor="khaki">
<h1>Mouse Drag Example</h1>
JSP DOCUMENTS
SHARAN K P Page 32
<jsp:plugin align="middle" height="500" width="500"
type="applet" code="MouseDrag.class" name="clock" codebase="."/> </body>
</html>
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 and operators in EL. It is the newly added feature in JSP technology version 2.0.
Syntax for Expression Language (EL)
1. ${ name }
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
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
JSP DOCUMENTS
SHARAN K P Page 33
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
<form action="process.jsp"> Enter Name:<input type="text" name="name" /><br/><br/> <input type="submit" value="go"/>
</form>
process.jsp
Welcome, ${ param.name }
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
JSP DOCUMENTS
SHARAN K P Page 34
<h3>welcome to index page</h3>
<% session.setAttribute("user","sonoo"); %>
<a href="process.jsp">visit</a>
process.jsp
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
&& and
|| or
?:
Reserve words in EL
There are many reserve words in the Expression Language. They are as follows:
JSP DOCUMENTS
SHARAN K P Page 35
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 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 requests. Modelrepresents the state of the application i.e. data. Viewrepresents the presentaion.
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 4 pages:
MServlet.java a servlet that acts as a controller.
login.jsp and welcome.jsp files acts as view components.
web.xml file for mapping the servlet.
MServlet.java In this servlet, we are simply checking the input values, if run this application first time, it will for the request to the login page without error message. If you type any other password than
sonoo, it will redirect again to the login page with error message. But if you type the password sonoo, it will redirect to the welcome page.
import java.io.IOException; import java.io.PrintWriter; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet;
JSP DOCUMENTS
SHARAN K P Page 36
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html");
PrintWriter out = response.getWriter(); String n=request.getParameter("name"); String p=request.getParameter("pass"); if(n==null){
RequestDispatcher rd=request.getRequestDispatcher("login.jsp");
rd.forward(request, response); } else if(n.equals("sonoo")){ RequestDispatcher rd=request.getRequestDispatcher("welcome.jsp"); rd.forward(request, response); } else{
request.setAttribute("error","true"); RequestDispatcher rd=request.getRequestDispatcher("login.jsp"); rd.forward(request, response); }
out.close(); } }
login.jsp
<% if(request.getAttribute("error")!=null){
out.print("Not valid user! Try again<hr>"); } %> <form action="servletM"> Name:<input type="text" name="name"/><br/> Password:<input type="password" name="pass"/><br/>
<input type="submit" value="login"/> </form>
welcome.jsp Welcome User!
web.xml <web-app>
JSP DOCUMENTS
SHARAN K P Page 37
<servlet>
<servlet-name>MServlet</servlet-name> <servlet-class>MServlet</servlet-class> </servlet>
<servlet-mapping> <servlet-name>MServlet</servlet-name> <url-pattern>/servletM</url-pattern> </servlet-mapping> <welcome-file-list>
<welcome-file>servletM</welcome-file> </welcome-file-list> </web-app>
next>>
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
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:
CREATE TABLE "USER432" ( "NAME" VARCHAR2(4000), "EMAIL" VARCHAR2(4000), "PASS" VARCHAR2(4000)
) /
We have created the table named user432 here.
JSP DOCUMENTS
SHARAN K P Page 38
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.
<form action="process.jsp"> <input type="text" name="uname" value="Name..." onclick="this.value=''"/><br/> <input type="text" name="uemail" value="Email ID..." onclick="this.value=''"/><br/> <input type="password" name="upass" value="Password..." onclick="this.value=''"/><br/> <input type="submit" value="register"/> </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.
<%@page import="bean.RegisterDao"%> <jsp:useBean id="obj" class="bean.User"/>
<jsp:setProperty property="*" name="obj"/> <% int status=RegisterDao.register(obj); if(status>0)
out.print("You are successfully registered"); %>
User.java
It is the bean class that have 3 properties uname, uemail and upass with its setter and getter
methods.
package bean; public class User { private String uname,upass,uemail;
public String getUname() { return uname; } public void setUname(String uname) { this.uname = uname;
}
public String getUpass() { return upass; } public void setUpass(String upass) {
this.upass = upass; } public String getUemail() {
JSP DOCUMENTS
SHARAN K P Page 39
return uemail;
} public void setUemail(String uemail) {
this.uemail = uemail; } }
Provider.java
This interface contains four constants that can vary from database to database.
package bean;
public interface Provider { String DRIVER="oracle.jdbc.driver.OracleDriver"; String CONNECTION_URL="jdbc:oracle:thin:@localhost:1521:xe"; String USERNAME="system"; String PASSWORD="oracle"; }
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.
package bean;
import java.sql.*;
import static bean.Provider.*; public class ConnectionProvider { private static Connection con=null; static{
try{ Class.forName(DRIVER); con=DriverManager.getConnection(CONNECTION_URL,USERNAME,PASSWORD); }catch(Exception e){} } public static Connection getCon(){
return con; }
}
RegisterDao.java
This class inserts the values of the bean component into the database.
package bean;
import java.sql.*; public class RegisterDao {
JSP DOCUMENTS
SHARAN K P Page 40
public static int register(User u){
int status=0; try{ Connection con=ConnectionProvider.getCon();
PreparedStatement ps=con.prepareStatement("insert into user432 values(?,?,?)"); ps.setString(1,u.getUname()); ps.setString(2,u.getUemail()); ps.setString(3,u.getUpass()); status=ps.executeUpdate();
}catch(Exception e){} return status; } }
Login and Logout Example in JSP
1. Login and Logout Example in JSP
2. Example of Login Form in JSP
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:
CREATE TABLE "USER432" ( "NAME" VARCHAR2(4000), "EMAIL" VARCHAR2(4000),
JSP DOCUMENTS
SHARAN K P Page 41
"PASS" VARCHAR2(4000)
) /
We assume that there are many records in this table.
index.jsp
It simply provides three links for login, logout and profile.
<a name="jsploginex"></a><a href="login.jsp">login</a>| <a href="logout.jsp">logout</a>| <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.
<%@ include file="index.jsp" %> <hr> <h3>Login Form</h3> <% String profile_msg=(String)request.getAttribute("profile_msg"); if(profile_msg!=null){
out.print(profile_msg); } String login_msg=(String)request.getAttribute("login_msg"); if(login_msg!=null){
out.print(login_msg); } %>
<br> <form action="loginprocess.jsp" method="post"> Name:<input type="text" name="name"><br><br> Password:<input type="password" name="password"><br><br> <input type="submit" value="login">" </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.
<%@page import="bean.LoginDao"%> <jsp:useBean id="obj" class="bean.LoginBean"/> <jsp:setProperty property="*" name="obj"/>
<% boolean status=LoginDao.validate(obj); if(status){ out.println("You r successfully logged in");
JSP DOCUMENTS
SHARAN K P Page 42
session.setAttribute("session","TRUE");
} else {
out.print("Sorry, email or password error"); %> <jsp:include page="index.jsp"></jsp:include> <% } %>
LoginBean.java
It is the bean class that have 2 properties email and pass with its setter and getter methods.
package bean; public class LoginBean { private String email,pass; public String getEmail() { return email;
} public void setEmail(String email) { this.email = email; }
public String getPass() { return pass; }
public void setPass(String pass) { this.pass = pass; }
}
Provider.java
This interface contains four constants that may differ from database to database.
package bean; public interface Provider { String DRIVER="oracle.jdbc.driver.OracleDriver";
String CONNECTION_URL="jdbc:oracle:thin:@localhost:1521:xe"; String USERNAME="system"; String PASSWORD="oracle"; }
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.
JSP DOCUMENTS
SHARAN K P Page 43
package bean;
import java.sql.*; import static bean.Provider.*;
public class ConnectionProvider { private static Connection con=null; static{ try{ Class.forName(DRIVER); con=DriverManager.getConnection(CONNECTION_URL,USERNAME,PASSWORD);
}catch(Exception e){} } public static Connection getCon(){ return con; }
}
LoginDao.java
This class varifies the emailid and password.
package bean; import java.sql.*; public class LoginDao {
public static boolean validate(LoginBean bean){ boolean status=false; try{ Connection con=ConnectionProvider.getCon(); PreparedStatement ps=con.prepareStatement( "select * from user432 where email=? and pass=?");
ps.setString(1,bean.getEmail()); ps.setString(2, bean.getPass()); ResultSet rs=ps.executeQuery(); status=rs.next();
}catch(Exception e){} return status; } }
Uploading file to the server using JSP
1. Uploading file to the server using JSP
JSP DOCUMENTS
SHARAN K P Page 44
2. MultipartRequest class
3. Constructors of MultipartRequest class
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.
<form action="upload.jsp" method="post" enctype="multipart/form-data">
Select File:<input type="file" name="fname"/><br/> <input type="image" src="MainUpload.png"/> </form>
upload.jsp
We are uploading the incoming file to the location d:/new, you can specify your location here.
<%@ page import="com.oreilly.servlet.MultipartRequest" %> <% MultipartRequest m = new MultipartRequest(request, "d:/new");
JSP DOCUMENTS
SHARAN K P Page 45
out.print("successfully uploaded");
%>
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.
<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.
<% String filename = "home.jsp"; String filepath = "e:\\"; response.setContentType("APPLICATION/OCTET-STREAM");
response.setHeader("Content-Disposition","attachment; filename=\"" + filename + "\"");
java.io.FileInputStream fileInputStream=new java.io.FileInputStream(filepath + filename); int i; while ((i=fileInputStream.read()) != -1) { out.write(i); }
fileInputStream.close(); %>