JSP
(Java Server Pages)
Submitted
by:
Mayank
Lovanshi
Sagar Pandya
Outline
Introduction to JSP
Advantages over Servlet
JSP Architecture
JSP Scripting Elements
Implicit Objects
Directives
Action tags
Life Cycle of JSP Page
MVC in JSP
Working with Databases
What is
JSP?
JavaServer Pages (JSP) is a server-side
programming technology that enables the
creation of dynamic, platformindependent method for building Webbased applications.
JSP have access to the entire family of
Java APIs, including the JDBC API to
access enterprise databases.
Advantages over Servlet
Extension to Servlet Technology
All features of Servlet
+
implicit objects, predefined tags,
expression language, Custom tags
Easily Managed
Separates business logic with presentation logic
Easily deployed
If JSP page is modified, no need to redeploy but
if changes are required in servlet , the entire code
needs to be updated and recompile
JSP Architecture
JSP
Servle
t
Engin
e
JSP
Architecture
JSP Processing:
1. Browser sends an HTTP request to the web server.
2. The web server recognizes that the HTTP request
is for a JSP
page (.jsp page) and forwards it to a JSP engine.
3. The JSP engine loads the JSP page from disk and
converts it into a servlet content. All template text is
converted to println( ) statements and all JSP
elements are converted to Java code that implements
the corresponding dynamic behavior of the page.
3.
CONTINUE..
4. The JSP engine compiles the servlet into an
executable class and forwards the original request to
a servlet engine.
5. Servlet engine loads the Servlet class and
executes it. & produces an output in HTML format,
which the servlet engine passes to the web server
inside an HTTP response.
6. The web server forwards the HTTP response to
your browser in terms of static HTML content.
JSP Architecture
JSP Processing:
JSP Scripting Elements
Three types of scripting elements:
Scriplet tag
Expression tag
Declaration tag
Scriplet tag
In JSP JAVA code can be written
inside the JSP page using Scriplet tag
Syntax:
<% java source code %>
Example:
<html>
<body>
<% out.print(Hello world);%>
</body>
</html>
Expression tag
Code placed within expression tag is
written to the output stream of the
response. So, no need to write out.print() to
write data. It is mainly used to print values
of variable or method
Syntax:
<%= Statement %>
Example:
<html>
<body>
<%= Hello world %>
</body>
</html>
Declaration tag
Used to declare fields and methods. The
code written inside this tag is placed
outside the service() method of auto
generated servlet .So it doesnt get
memory at each request
Syntax:
<%! Statement %>
Example:
<html>
<body>
<%! int data=60;%>
<%= Value is: + data %>
</body>
JSP Implicit Objects
Object
Out
Request
Response
Config
Application
Session
pageContext
Page
Exception
Type
JspWriter
HttpServletRequest
HttpServletResponse
ServletConfig
ServletContext
HttpSession
PageContext
Object
Throwable
JSP Directives
Directives are messages that tells the
web container how to translate a JSP
page into corresponding servlet.
Three types:
page directive
include directive
taglib directive
Syntax of JSP directives
<%@ directive attribute=value %>
page directive
Defines attributes that apply to an
entire JSP page
Syntax:
<%@ page attribute=value %>
Attributes :
import ,contentType, extends, info, buffer,
language,autoFlush,
session, pageEncoding, errorPage, isErrorPage
Include directive
Includes the contents of any
resource(may be jsp file, html file or
text file
It includes the original content of the
included resources at page
translation time
Reusability is the advantage
Syntax:
<%@include file=resourcename
%>
taglib directive
Used to define a tag library that
defines many tags
We use the TLD (Tag Library
Descriptor) file to define the tags
Syntax:
<%@ taglib uri=uriofthetaglibrary
prefix=prefixoftaglibrary%>
JSP Action tags
Used to control the flow between
pages and to use java beans
Following are JSP Action tags:
jsp:forward
jsp:include
jsp:param
jsp:useBean
jsp:setProperty
jsp:getProperty
Uses Bean
Class
jsp:forward
Forwards the request to another
resource, it may be jsp, html or another
resource
Syntax:
<jsp:forward page=relativeURL |<
%=expression%> />
With parameter:
<jsp:forward page=relativeURL |<
%=expression%> />
<jsp:param name=parametername
value=parametervalue|<%=expression%>
/>
jsp:include
Includes the resources at request time.
Here file is being included during
request processing phase
Syntax:
<jsp:include page=relativeURL |<
%=expression%> />
With parameter:
<jsp:include page=relativeURL |<
%=expression%> />
<jsp:param name=parametername
value=parametervalue|<%=expression%>
/>
Java Beans
is a Java class
It should not have
argument/parameterized constructor
It should be serializable
It should provide methods to set and
get the values of the properties
(getters/setters)
It is a reusable software components
Example of java Bean Class
Employee .java
jsp:useBean
To instantiate a Bean Class
If bean object of Bean class is already
created , it does not create the bean
If object of Bean is not created ,it
instantiates the Bean
Syntax:
<jsp:useBean id=instancename
scope=page | request | session |
application
class=packagename.classname
type=packagename.classname
beanName=packagename.classname | <
%=expression %> />
Attributes of jsp:useBean
Attribute Description
s
Id
To identify the Bean in specified scope
scope
Default scope is page
1) page- specifies bean can be used within JSP
page
2) request specifies bean can be used from
any JSP page that processes the same
request. Wider scope than Page
3) session - specifies bean can be used from any
JSP page in the same session whether
processes the same request or not. Wider
scope than request
4) application - specifies bean can be used from
any JSP page in the same application. Wider
scope than session
class
Instantiates the specified bean class (i.e.
creates an object of the bean class)
type
Provides the bean data type if the bean already
jsp:setProperty
Sets a property value or values in a
bean using the setter method
Syntaxes:
1) Setting all values of incoming
request in the bean
<jsp:setProperty
name=instanceofBean
property=* />
2) Setting value of incoming
specific property
<jsp:setProperty
name=instanceofBean
jsp:getProperty
Returns the value of the property
Syntax:
<jsp:getProperty
name=instanceofBean
property=propertyName />
Life cycle of JSP page
A JSP life cycle can be defined as the
entire process from its creation till the
destruction similar to a servlet life
cycle with an additional step of
compiling a JSP into servlet.
The following are the paths followed
by a JSP
Compilation 3 steps
Parsing jsp
Turning the JSP into a servlet
Compiling the servlet
Initialization
Life cycle of JSP page
jspInit()
Request
_jspService()
Response
[destroy]
jspDestroy()
Life cycle of JSP page
JSP Initialization:
- When a container loads a JSP it invokes
the jspInit() method before servicing any
requests.
- If you need to perform JSP-specific
initialization, override the jspInit() method:
public void jspInit()
{
// Initialization code...
}
- initialization is performed only once
- generally initialize database connections,
open files, and create lookup tables in this
Life cycle of JSP page
JSP Execution:
- Whenever a browser requests a JSP and
the page has been loaded and initialized,
the JSP engine invokes the _jspService()
method in the JSP.
void _jspService(HttpServletRequest
request, HttpServletResponse
response)
{
// Service handling code...
}
- This method is invoked once per request
and is responsible for generating the
Life cycle of JSP page
JSP Cleanup:
- The destruction phase when a JSP is being
removed from use by a container.
- The jspDestroy() method is the JSP
equivalent of the destroy method for
servlets.
- Override jspDestroy when you need to
perform any cleanup, such as releasing
database connections or closing open files.
public void jspDestroy()
{
// Your cleanup code
}
MVC in JSP
MVC Model View Controller
It is a design pattern that separates the
business logic ,presentation logic and data
Model represents the state(data) and
business logic of the application (Eg. Java
Beans)
View responsible for display data or
presentation ( Eg.JSP/HTML pages)
Controller
Acts as interface between view and
model
Receives input and commands to
Model/View to change accordingly
(Eg . Servlet page)
MVC Architecture
1
Request
(Client)
Browser
(Controller)
Servlet
2
instantiate
5
Response
(View)
JSP
Application
server
(Model
)
Java
Beans
Enterpr
ise
Servers
/
Data
sources
THANK YOU !
