J S P (JSP) : AVA Erver AGE

JAVA SERVER PAGE(JSP)
Prepared by:-Jaydeep R. Viradiya

JSP INTRODUCTION
 JavaServer Pages (JSP) is a server-side programming
technology that enables the creation of dynamic,
platform-independent method for building Web-based
applications.
 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
CONTINUE…
 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.
JSP VS SERVLET
Servlet JSP
 Handles Business Logic  Handles Presentation Logic

 Lifecycle Methods  Lifecycle Methods
 init()-can be overridden  Jspinit()-can be overriden
 Service() -can be overridden  _jspservics()-can be overridden
 Destroy() -can be overridden.  Jspdestroy()-can be overriden
 HTML within Java  Java within HTML

IN THE END ,A JSP IS JUST A SERVLET
Is loaded and
initialized as
Is translated to Compiles to
Import 010101
JSP javax. 010100
sevlet. 101010 Servlet
Httpservlet 010
Myjsp.jsp Myjsp_jsp.java Myjsp_jsp.class
LIFE CYCLE OF A JSP PAGE
ADVANTAGE OF JSP OVER SERVLET
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.
EASY TO MAINTAIN
 JSP can be easily managed because we can easily
separate our business logic with presentation
logic.
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.
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.
JSP ELEMENTS
 Need to write some java in your HTML?
 Want to make Your HTML more dynamic
Jsp Declarations :: Code that goes outside the service method
Jsp Scriplets :: Code that goes within the service method
Jsp Expressions :: Code inside expression is evaluated
Jsp Directives :: Commands given to the JSP engine

JSP ELEMENTS- DECLARATIONS
 What are declarations?
 Whatever goes inside the “<%!{JAVA_HERE}>” tag is
called a declaration.
 Everything you write in a declaration goes outside the
service method
 Treat them as instance method and instance variables
What do you declare in declarations?
you can declare methods and variable in declarations.

Why do you need declarations?
You have any variable that needs to be shared across
different requests
You have repeated common code in your JSP ,
declare it in a method.
Example:
<%! Int var=10; %>
JSP Elements - Declarations
Request 1
Service1 Service2 Service3
Request 2
Declarations
Request 3
14
JSP ELEMENTS - SCRIPLETS
 What are Scriplets?
 Whatever goes inside “<%JAVA_HERE%>” tag is called a
scriplet
 Everything you write in a scriplet goes in the sevice method
 Treat variables in scriplets as methods/local variables
 What do you put in scriplets?

 Business logic in JSPs are put in scriplets. Set of java
statements
Why do you need scriplets?
Need to perform some small business logic
Need to perform some basic validations
Example
<% int localVar=10; %>
EXAMPLE
JSP ELEMENTS : EXPRESSIONS
 What are Expressions?
 Whatever goes inside the “<%={JAVA_HERE}%>” tags is called
an expressions
 Code inside expressions is evaluated, and output is displayed.
 Whatever is put inside expressions should evaluate to value.
What do you put in Expressions?

Variables or methods that return some values.
Why do you need expressions?

Need to print some text onto the page.
Example:
<%= localvar %>
EXAMPLE
JSP Elements - Example
<html><head><title>JSP Elements Example</title>

</head>
<body> Declarations
<%! int userCnt = 0; %>
<% Scriptlets
String name = "Sharad";
userCnt++;
%> Expressions
<table>
<tr><td>
Welcome <%=name%>. You are user number <%=userCnt%>
</td></tr>
</table>
</body>
</html>
19
JSP ELEMENTS :- DIRECTIVES
 What are Directives?
 Whatever goes inside “<%@{Directives}%>” tags are called directive
 Directives gives pre-processing commands to the JSP engine.
 Everything in directives are processed before jsp is translated to servlet
What do you put in directives?

Processing command to the JSP engine.
Why do you need directives?
To incorporate certain additional features into the jsp.
Modifying the servlet behaviour generated from the jsp.
Include other HTML/JSP file in the JSP
Provide tags Libraries
Example:
<%@ page import =“java.util.ArrayList” %>
THERE ARE THREE TYPES OF DIRECTIVE
TAG:
Directive Description
<%@ page ... %> Defines page-dependent attributes, such as

scripting language, error page, and buffering
requirements.
<%@ include ... %> Includes a file during the translation phase.
<%@ taglib ... %> Declares a tag library, containing custom

actions, used in
DIRECTIVES: PAGE DIRECTIVE
 Any number of pre-defined attributes can be added to
the page directive.
<%@ page import = “{IMPORTED CLASS}”

contentType = “{CONTENT_TYPE}”
isThreadSafe = “{true/false}”
session = “{true/false}”
Buffer = “{BUFFER_SIZE}”
autoFlush = “{true/false}”
extends = “{EXTENDS_FROM_PAGE}”
info = “{PAGE_INFO}”
errorPage = “{ERROR_PAGE_NAME}”
isErrorPage = “{true/false}”
language = “{LANGUAGE}”
DIRECTIVES: INCLUDE DIRECTIVE
 Including other page content into your JSP.
 <%@ include file ={PAGE_URL_TO_INCLUDE}%>
 Includes file at translation time.
 If include file is modified , the main jsp needs need to be
recompiled
DIRECTIVES: TAGLIB DIRECTIVE
 Providing output based on common custom logic
<%@ taglib uri=“{TLD_FILE}” prefix=“{prefix}” %>

 For creating any custom tag, we need to follow following
steps:
Create the Tag handler class and perform action at the

start or at the end of the tag.
Create the Tag Library Descriptor (TLD) file and

define tags
Create the JSP file that uses the Custom tag defined
in the TLD file
FLOW OF CUSTOM TAG IN JSP
TAGLIB LIBRARY – HIGH LEVEL OVERVIEW
<%@ taglib uri=“jspTag” prefix=“mytag”%>
----
<mytag:txtbox length=“10” name = “username”/>
jspTag-taglib-tld
Test.jsp <tag>
<name>txtbox</name>
<tagclass>txtboxclass</tagclass>
</tag>
Txtboxclass.java
Web.xml Public class txtboxclass extends Tagsuport
<web-app>
<taglib> {
<taglib-uri>jspTag</taglib-uri> Public int doStartTag()
<taglib-location>jspTag-taglib-tld {
</taglib-location> --------
</taglib> }
</web-app> }
IMPLICIT OBJECTS- INTRODUCTION
 Set of predefined objects readily available for use.
 Out : JspWriter
 Request : HttpRequest
 Response : HttpResponse
 Session : HttpSession
 Config : ServletConfig
 Application : ServletContext
 Page : Jsp Page
 Page context : special objects
IMPLICIT OBJECTS:- OUT
 An instance of JspWriter
 Writes statements to the page
 The java way to display text on the webpage
 Displaying dynamic data

IMPLICIT OBJECTS: REQUEST
 Instance of HttpServletRequest
 Use the attributes stored in request object for
display/basic validation in JSP.
Forward request to JSP

Servlet Jsp page
request.setAttribute(“a “,“10”)
Helper
Object
Uses helper (a=10)
object
IMPLICIT OBJECTS: RESPONSE
 Instance of HttpServletResponse
 Send the response back to the client
Send response to the client

JSP1
Response.sendredirect(“jsp2”)
Send response to
Redirect to JSP
page the client
JSP1 JSP2
IMPLICIT OBJECTS : SESSION
 Instance of HttpSession
 Retrieve and set the session attributes in JSP
 Remember client across multiple requests
Request1
Client
Response1
Web App
Request2
Response2
IMPLICIT OBJECTS : CONFIG AND
APPLICATION
 Config : instance of ServletConfig

 Application: instance of servletContext
servletContext
JSP JSP JSP
ServletConfig ServletConfig ServletConfig

Implicit Objects – page
Hello <%=userName%>
<jsp:include page=“/header.jsp"/>
header.jsp
Main page
<table><tr>
<td>Contact Details</td>
<tr></table>
<jsp:include page=“/footer.jsp"/>
footer.jsp
main.jsp 33
Implicit Objects – pageContext
application
Least visible to most visible
session
pageContext
request
page
34
JSP Actions
• Special tags which provides special features
• The container handles these tags in a special way
• Addresses certain common functionalities
• Achieve functionality with less code, and more standard way
<jsp:include>
<jsp:forward>
<jsp:param>
<jsp:useBean>
<jsp:getProperty>
<jsp:setProperty>
35
JSP Actions - <jsp:include>
Definition:
Includes a page at the given location in the main page
Syntax:
<jsp:include page="{PAGE_TO_INCLUDE}" flush="true" />
36
JSP Actions – Include Action v/s Include Directive
Include Directive Include Action
Translation time Run time
Copies the included file References to the included file
For static content For dynamic content
Cannot pass parameters Can pass parameters
37
JSP Actions - <jsp:forward>
Definition:
Forwards the request to the given page
Syntax:
<jsp:forward page=“{PAGE_TO_FORWARD}" />
38
JSP Actions - <jsp:param>
Definition:
Pass parameters to the included/forwarded page
Syntax:
<jsp:include page="{PAGE_TO_INCLUDE}" flush="true" >

<jsp:param name=“{parameterName}” value="{paramValue}" />
</jsp:include>
<jsp:forward page="{PAGE_TO_FORWARD}" flush="true" >

<jsp:param name=“{parameterName}” value="{paramValue}" />
</jsp:forward>
39
A JAVABEAN
A Javabean is a ordinary java class that conforms to the following
rules:
 A javabean must have a public,no argument constructor(a default

constructor).
 The javabean class attributes must be accessed via accessor and

mutator methods that follow a standard naming convention(getxxxX()
and setxxxX(),isxxxX() for boolean attributes)
 Javabean class should implement the serializable interface.

WHY USE JAVABEANS
Using javabeans rather than java scriplets in your JSPs

allow better separation of the view logic from the
business logic.
Java in a JSP
* Java Scriplets
* Include Statement
* Javabeans
JSP Actions - <jsp:useBean>
getId();
setId(..)
getName()
How can I use
setName(…)
that bean?
bean
Servlet JSP
request.setAttribute(“userBean”, userBean”) <jsp:useBean …./>
42
JSP Actions - <jsp:useBean>
Definition:
Instantiate a bean class, use bean properties, and set property values
Syntax:
<jsp:useBean id=“{beanInstanceName}"
scope="page|request|session|application"
class=“{package.class}" >
</ jsp:useBean>
UserBean ub = new UserBean();

43
JSP Actions - <jsp:getProperty>
Definition:
Gets property values of a Bean
Syntax:
<jsp:getProperty name=“{beanInstanceName}"
property= “{propertyName}">
44
JSP Actions - <jsp:setProperty>
Definition:
Sets property values in a Bean
Syntax:
<jsp:setProperty name=“{beanInstanceName}"
property= "*" | property="propertyName"
param=“{parameterName}"
value="{paramValue}" } />
45
JSP Actions – useBean
<jsp:useBean id=“userBean"
scope="session“
class=“com.jaydeep.UserBean" >
<jsp:setProperty name=“userBean”
property=“userName”
value=“jaydeep”/>
</ jsp:useBean>
<jsp:getProperty name=“userBean" property=“userName" />
46
Error Handling – Types of errors
• Errors in java code in scriptlets

 handle errors in try/catch block
 may occur at runtime
• Errors in HTML
 adhere to the HTML rules
 can be caught during testing 47

Error Handling
Why is error handling important in JSPs?
48
Error Handling – Error page
• Error pages come to the rescue
<%@page isErrorPage="true" %>

<html>
<head>
<title>My Error Page</title>
</head>
<body>
We are sorry, the page you are
trying to access is currently not
available. Please try after some time
</body>
</html>
49
Error Handling
• Specify error page in your main page • Specify error page in web.xml
<%@page errorPage=“errPage.jsp" %> <web-app>
<html> …………….
<head> ……………
<title>This is the main page</title>
</head> <error-page>
<body> <exception-type>com.a.myExp</exception-type>
………………….. <location>/error.jsp</location>
………………….. </error-page>
…………………… <error-page>
…………………… <error-code>404</error-code>
<location>/errorServlet</location>
// ERROR CODE GOES HERE </error-page>
………………….
…………………. ………………..
</body> ……………….
</html> </web-app>
50
Thanks
51

J S P (JSP) : AVA Erver AGE

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

J S P (JSP) : AVA Erver AGE

Uploaded by

Copyright:

Available Formats

JAVA SERVER PAGE(JSP)

Prepared by:-Jaydeep R. Viradiya

 Handles Business Logic  Handles Presentation Logic

 HTML within Java  Java within HTML

 If JSP page is modified, we don't need to

 Want to make Your HTML more dynamic

Jsp Declarations :: Code that goes outside the service method

Jsp Scriplets :: Code that goes within the service method

Jsp Expressions :: Code inside expression is evaluated

Jsp Directives :: Commands given to the JSP engine

What do you declare in declarations?

you can declare methods and variable in declarations.

Service1 Service2 Service3

 What do you put in scriplets?

What do you put in Expressions?

Why do you need expressions?

<html><head><title>JSP Elements Example</title>

What do you put in directives?

<%@ page ... %> Defines page-dependent attributes, such as

<%@ taglib ... %> Declares a tag library, containing custom

<%@ page import = “{IMPORTED CLASS}”

<%@ taglib uri=“{TLD_FILE}” prefix=“{prefix}” %>

Create the Tag handler class and perform action at the

Create the Tag Library Descriptor (TLD) file and

 Writes statements to the page

 The java way to display text on the webpage

 Displaying dynamic data

Forward request to JSP

Send response to the client

 Remember client across multiple requests

 Config : instance of ServletConfig

JSP JSP JSP

ServletConfig ServletConfig ServletConfig

• Special tags which provides special features

• The container handles these tags in a special way

• Addresses certain common functionalities

• Achieve functionality with less code, and more standard way

<jsp:include page="{PAGE_TO_INCLUDE}" flush="true" />

Include Directive Include Action

Translation time Run time

Copies the included file References to the included file

For static content For dynamic content

Cannot pass parameters Can pass parameters

<jsp:forward page=“{PAGE_TO_FORWARD}" />

<jsp:include page="{PAGE_TO_INCLUDE}" flush="true" >

<jsp:forward page="{PAGE_TO_FORWARD}" flush="true" >

 A javabean must have a public,no argument constructor(a default

 The javabean class attributes must be accessed via accessor and

 Javabean class should implement the serializable interface.

Using javabeans rather than java scriplets in your JSPs

request.setAttribute(“userBean”, userBean”) <jsp:useBean …./>

UserBean ub = new UserBean();

<jsp:getProperty name=“userBean" property=“userName" />

• Errors in java code in scriptlets

 adhere to the HTML rules

 can be caught during testing 47

Why is error handling important in JSPs?

• Error pages come to the rescue

<%@page isErrorPage="true" %>

You might also like