JSP Notes
JSP Directives (Directives are used during the translation phase;
all other elements are used during request processing phase)
1. JSP : <%@ include file={static html file or regular
jsp file} %>
XML: <jsp:directive.include file= "relativeURLspec"
/>
Example:<%@ include file="file2.jsp" %>
Description: includes file as part of the translation
unit, which is compiled into a servlet; a page may include multiple include
directives
2. JSP : <%@ page{…} %>
XML: <jsp:directive.page pageDirectiveAttrList />
Example:
Import a Java class into the JSP page <%@ page import=”java.util.Date”
%> (Multiple declarations are separated by comma)
Declare that a JSP page exists within a session <%@
page session=”true”%>
Declare that a JSP page uses an error page <%@
page errorPage=”errorPage.jsp” %>
Declare that a JSP page is an error page <%@ page
isErrorPage=”true” %>
Description:Defines attributes that apply to a JSP
page. assigns various page-dependent attributes; defaults are given below
pageDirectiveAttrList:
1. language= “java”
2. contentType= “mimeType [;charset=characterSet]
| text/html; charset=ISO-8859-1"
3. import=“java.util.Date, java.util.DateFormat”
{may have more than one importassignments via multiple page directives}
4. session=“true | false”
(if set to false, the implicit session variable is not available to scripting
elements)
5. isErrorPage= “false | true
” (set to true if this page is used as anerror page, and it will have
the implicit exception variable available to scripting elements)
6. errorPage=“relativeURL" (no default;
page-relative or context-relative URI to redirect toin case exception thrown)
7. autoFlush=“true | false”
(if false, throws exception when buffer is full)
8. buffer=“8kb | none | sizekb
” (defines size of buffer; “none” to disable buffering)
9. info=“text" (no default; used
by server administrative tool as a description ofthe jsp page)
10. isThreadSafe= “true | false”
(if set to false, then will useSingleThreadModel)
11. extends=“package.class" (no default;
fully qualified classname to extend; class must implement JspPage or HttpJspPage
interface)
3. JSP : <%@ taglib uri="URI" prefix="tagPrefix" %>
XML: No equivlalvent included in Root
Example : <%@taglib uri="/tomcat/taglib" prefix="test">
Description:
1. declares a tag library, containing custom actions, that
is used in the page
1. prefix= “tagPrefix" (mandatory;
no default; specifies prefix to use in the action element names for all
actions in thelibrary)
2. uri=“URI” (mandatory; no default;
either a symbolic name for the tag libraryin the web.xml file or a page-
or context-relative uri for the library’sTLD or JAR file)
JSP Scripting Element - Declaration
JSP : <% code fragment %>
XML: <jsp:scriptlet> code fragment </jsp:scriptlet>
Example: <%! String mystring = new String(“hello”);
%>
Description:
1.must be a valid java variable declaration;
2.declares instance variables of the JSP implementation class;
3.thread-safe alternative is to declare variables in scriptlets,
so they are local variables
4.may also declare methods within a Declaration element
5.JSP implicit variables are not visible in a declaration
element, since they are declared within the _jspService() method.
JSP Scripting Element - Expression
JSP : <%= expression %>
XML:<jsp:expression>expression </jsp:expression>
Example: <%= 1+2 %> or <%= mystring
%>
Description:
1. must be complete valid java expression that results
in or can be converted to a string.
2. all JSPimplicit variables are visible in an expression
element
JSP Scripting Element - Scriptlet
JSP <% code fragment %>
XML<jsp:scriptlet>code fragment</jsp:scriptlet>
Example: <% if (1+2==true) { %> yippee!! <%
} else { %> boohoo!! <% } %>
Description:
1.scriptletcode fragments are combined with code for
sending template data between them tothe browser; the combination of all scriptlets
in a page must form valid javacode
2.all JSPimplicit variables are visible in a scriptlet
element
a) Directive - <%@ Directive {attribute=”value”}* %>
--controls translation and compilation phase.
b) Declaration - <%! JavaDeclaration %>
--declare a
java variable or method. No output produced. Class level declarations.
c) Scriptlet - <% JavaStatements %>
--valid java statements. No output produced
unless out is used
d) Expression - <%= JavaExpression %>
--evaluation of expression to a String and then included in the output.
JSP Action Elements
<jsp:forward>
JSP : <jsp:forward page="{relativeURL | <%= expression
%> }" { /> | >
[ <jsp:param
name="parameterName" value="{parameterValue
| <%= expression %>}" /> ] + </jsp:forward> }
XML : Same JSP Syntax
Example:<jsp:forward page= {page- or context-relative uri of
jsp or servlet} />
uses RequestDispatcher to forward control to another resource; see
RequestDispatcher.forward restrictions
<jsp:include> Includes a static file or the result from another web
component.
JSP <jsp:include page="{relativeURL | <%= expression %>}"
[ flush="true | false" ]{ /> | >
[
<jsp:param name="parameterName" value="{ parameterValue
| <%= expression %>}" /> ] +</jsp:include> }
XMLSame JSP Syntax
Example: <jsp:include page= {page- or context-relative uri of jsp or
servlet} flush= “true” />
uses RequestDispatcher to include output from another resource; see
RequestDispatcher.include restrictions
<jsp:useBean> Locates or instantiates a bean with a specific name
and scope.
JSP <jsp:useBean id="beanInstanceName" scope=" page|request|session|application"
{ class="package.class"
[ type="package.class" ] | beanName="{package.class | <%= expression %>}"
type="package.class" |type="package.class "}{ /> | > other elements
</jsp:useBean> }
XMLSame JSP Syntax
3. <jsp:useBean{…} >
associates a java bean with a name in one of the JSP scopes and also
makes it available as a scripting variable; instantiates the bean if it doesn’talready
exist as the given id
class = {fully qualified classname for the bean}
id ={java variable name to use}-- variable name is made available
via <jsp:getProperty..> as well as a scripting variable
scope ={page(default), request, session or application}--
stores bean object in pageContext, request, session or context attribute,respectively
type ={optional; defines a type to which the bean should
be cast; class must be a subclass of type or, if type is an interface, class
must implement type}
beanName ={optional; the beanName parameter as expected
by the java.beans.Beans.instantiate() method}
Note:jsp:useBean action element can have a non-empty
body, e.g. a jsp:setProperty action; the body will be executed for newly
instantiated beans only
4.<jsp:setProperty> Sets a bean property value or values.
JSP <jsp:setProperty name="beanInstanceName "
{ property="*" |
property="propertyName " [ param="parameterName" ] | property="propertyName
" value="{string | <%= expression%>}" } />
XML Same JSP Syntax
Example: <jsp:setProperty {…} /> -- sets value of
myClock’s property(s)
name= “myClock”
property=“date” (if “*”, then will
set all properties with names matchingrequest parameters)
param=“…” (optional; explicitly specifies
a request parameter that holdsvalue to use for specified property)
value=“…” (optional: explicitly specifies a
value to assign to the property;value cannot be used in conjunction with
param; value can be set equal to an expression e.g. value= “<%= newjava.util.Date()%>”)
if property value is a String, it is converted
to the target property’stype, e.g. Float.valueOf(String)
5.<jsp:getProperty> Inserts the value of a bean property into the
result.
JSP <jsp:getProperty name="beanInstanceName "property="propertyName"
/>
XML Same JSP Syntax
Example : <jsp:getProperty name= “myClock” property= “date”
/> -- same as the expression <%=myClock.date %>
JSP Implicit Variables
1. request: the HttpServletRequest object for
the current request
2. response: the HttpServletResponse object for
the current request
3. session: the HttpSession as per request.getSession();
you may call session.invalidate()to implement a logout
4. application:the ServletContext as per GenericServlet.getServletContext();
application.log()can be used to write to the application log file
5. out:assigned by web container to a concrete
subclass of JspWriter (which emulatessome of the functionality found PrintWriter
and BufferedWriter, but throwsIOException unlike PrintWriter)
6. exception:only available in error pages
7. config: theServletConfig as returned by GenericServlet.getServletConfig()ß
used by web container to pass info to servlet or JSP duringinitialization
(e.g init parameters, context, servletname)
8. pageContext:used by the container; a pageContext
instance provides access to all of thescopes associated with a JSP page, provides
access to several page attributesandall the JSP implicit variables. A unique
instance of this object is created bythe web container and assigned to the
pageContext variable for each request, andis used in the JSP implementation
class (servlet) to initialize the JSP implicitvariables.
9. page:assigned to the instance of the JSP implementation
class (servlet) declared asan Object
JSP Page Lifecycle
1. The Translation Phase includes the following
and is initiated either
(1) whenthe first request for a new or
updated JSP page is received, or
(2) at deployment time, depending on the
application server
2. Page Translation: The JSP page is translated into
Java servlet code.
3. JSP PageCompilation: The servlet code is compiled
into a JSP pageimplementation class.
4. The Execution / Request-Processing Phase includes
the following and is the sameas for a regular servlet.
5. Load Class: The JSP page implementation class is
loaded by the JVM.
6. CreateInstance: The JSP page implementation
class is instantiated.
7. Call jspInit: jsp_init() is invoked when the
JspPage is initialized. At this pointgetServletConfig() will return the desired
value.
8. Call _jspService: _jspService corresponds to
the body of the JSP page. This method isdefined automatically by the JSP processor
and should NEVER BE DEFINED BY THEJSP AUTHOR.
9. Call jspDestroy: jsp_destroy() is invoked when
the JspPage is about to be destroyed.