SCWCD : Java server pages CHAP : 9

1
Java Server Pages (JSPs)
Helmi ben abdallah @rchitect JEE

2
THE FOLLOWING SUN CERTIFIED WEB COMPONENT
DEVELOPER FOR J2EE PLATFORM EXAM OBJECTIVES
COVERED IN THIS CHAPTER:
• 8.1 Write the opening and closing tags for the following JSP tag
types: Directive ,Declaration ,Scriptlet ,Expression .
• 8.2 Given a type of JSP tag, identify correct statements about its
purpose or use.
• 8.3 Given a JSP tag type, identify the equivalent XML-based tags.
• 8.4 Identify the page directive attribute, and its values, that:
> Import a Java class into the JSP page
> Declare that a JSP page exists within a session
> Declare that a JSP page uses an error page
> Declare that a JSP page is an error page

3
• 8.5 Identify and put in sequence the following elements of the
JSP page life cycle: Page translation ,JSP page compilation,
Load class,Create instance,Call jspInit,Call _jspService ,Call
jspDestroy .
• 8.6 Match correct descriptions about purpose, function, or
use with any of the following implicit objects: request,
response ,out ,session ,config ,application ,Page ,pageContext,
exception .
• 8.7 Distinguish correct and incorrect scriptlet code for: A
conditional statement , An iteration statement
• 9.1 Given a description of required functionality, identify the
JSP page directive or standard tag in the correct format with
the correct attributes required to specify the inclusion of a
web component into the JSP page.

4
• 10.1 For any of the following tag functions, match the correctly
constructed tag, with attributes and values as appropriate, with the
corresponding description of the tag’s functionality:
o Declare the use of a JavaBean component within the page.
o Specify,for jsp:useBean or jsp:getProperty tags, the name of an attribute.
o Specify, for a jsp:useBean tag, the class of the attribute.
o Specify, for a jsp:useBeantag, the scope of the attribute.
o Access or mutate a property from a declared JavaBean.
o Specify, for a jsp:getProperty tag, the property of the attribute.
o Specify, for ajsp:setProperty tag, the property of the attribute to mutate,
and the new value.
• 10.2 Given JSP page attribute scopes: request ,session , application ,
identify the equivalent servlet code.
• 10.3 Identify techniques that access a declared JavaBean component.

5
The JSP Model
• The JSP model relies on two main objectives. The first is
to allow and encourage the separation of the Presentation
layer from Java code.
• The second objective is to enable developers to author
web pages that have dynamic content, with maximum
power and flexibility.

6
Servlet code versus JSP code

9
Servlet inheritance hierarchy
•void jspInit() is invoked when the first request is made to initialize the JSP.
•void jspDestroy() is invoked by the container to clean up resources for example, when the
container shuts down, or when the generated servlet is unloaded from memory.
•void _jspService(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException captures every JSP request. (The _jspService(…) method is to the
JSP as the service(…) method is to the servlet.
The implementation for this method is generated by the container and should not be overridden.

10
JSP life cycle
• Initially, the first client who accesses the JSP page will
experience a delay, known as the first-person penalty. This
delay results from the time required to generate and compile (or
translate) the JSP into a servlet.

11
• 1. Translate the page (.jsp to .java).
• 2. Compile the JSP page (.java to .class).
• 3. Load the class.
• 4. Create the instance.
• 5. Call jspInit() when the page is first initialized.
• 6. Call_jspService(…) for every request made to the
JSP.
• 7. Call jspDestroy() when the JSP is destroyed by the
server.

12
JSP Elements
• This section covers the following element
types:
> Hidden comment
> Declaration
> Expression
> Scriptlet
> Directive

14
Declaration
• A declaration declares Java variables or methods that
future Java code can access within the JSP page.

16
• The methods jspInit() and jspDestroy() can be implemented
within a declaration.
• These methods are called by the servlet’s init() and destroy()
methods. The JSP, however, cannot override the servlet’s init()
and destroy() methods because they are declared final by the
background servlet.

17
Expression
• It indicates a variable or method invocation whose
resulting value is written to the response output stream.

18
• When an expression element is encountered, the expression
itself is
1. Evaluated
2. Converted to a String object
3. Inserted into the response output stream
• Expressions are generally not terminated with a semicolon.
(Some servers do not require a semicolon; others do).
• They are evaluated from left to right.
• They can be composed of more than one part or expression.
The ternary operator provides an example of how multiple
expressions can exist within a single expression:
<%= (boolean evaluation) ?
(true expression) :
(false expression) %>

19
Scriptlet
• When a scriptlet is translated to the servlet, it is placed within
the _jspService(…) method. Consequently, static blocks
cannot be defined within a scriptlet.

21
Within the scriptlet, you can include the following tag
types:
• Declaration (variable, method, class)
• Expression (valid variable or method invocation)
• Any implicit or explicit object declared with a jsp:useBean element.
• Any valid scripting language statement

22
Statements
• The first is how curly braces are handled.
• the second is how code is interpreted within and
outside the scriptlet block.

23
Directive
• A directive enables a JSP page to control the overall structure
for the translation phase of the servlet.
• Directives provide global information independent of a specific
request. Some examples include incorporating classes or other
files, and defining page characteristics. The three types of
directives are as follows:
> The include directive
> The page directive
> The taglib directive

24
The include Directive
• The include directive includes a static file in a JSP page.
JSP Syntax
<%@ include file=“relativeURL” %>
XML Syntax
<jsp:directive.include file=“relativeURL” />

25
The purpose of an include directive is to insert a file in a JSP page when it is
translated. The types of files consist of a JSP page, HTML file, XML
document, or text file.

26
• If the included file is a JSP page, the JSP elements are
translated and included in the JSP page. After the include file
is translated, the translation process continues with the original
JSP.
• The value for the file attribute is relative, which means the path
consists of the URL minus the protocol, port, and domain
name. Some examples include:
> error.jsp
> temp/buyNow.html
> /beans/generateReceipt.jsp
• When the relative path starts with a forward slash (/), the path
is relative to the JSP application’s context.
• If the relative URL starts with a directory or filename, the path
is relative to the JSP page.

27
The page Directive
• A page directive defines attributes that apply to an entire JSP
page.
• JSP Syntax
<%@ page ATTRIBUTES %>
A page directive is used to provide information to the JSP page.
Consequently, many attribute values are used to define data
for the page.

30
Example
<%@ page import=”java.io.*, java.util.*” %>
<%@ page language=”java” pageEncoding=”ISO=8859-01”
%>
XML Syntax
<jsp:directive.page pageDirectiveAttribute [+
pageDirectiveAttribute] />
Example
<jsp:directive.page errorPage=“error.jsp”
extends=“java.awt.Color” isThreadSafe=“true” />
The attributes apply to the entire JSP page and any static
include files.
The combination of the two is referred to as a translation unit.

31
The following rules apply to the page
directive:
• You can use the page directive more than once in a
translation unit.
• You can use a page attribute only once in a translation
unit, except for import. (The import statement operates
similarly to Java code.)
• A page directive can be placed anywhere within the JSP
page or included files. (It is good practice to place it at the
top of the JSP page.)

32
The taglib Directive
• A taglib directive defines a tag library and prefix for the custom tags
used in the JSP page.
• JSP Syntax
• <%@ taglib uri=“URIForLibrary” prefix=“tagPrefix” %>
• Example
• <%@ taglib uri=“ http://www.company.com/tags “ prefix=“public” %>
• <public:loop>
• …
• </public:loop>
• XML Syntax
• None

33
• The taglib must be defined before the use of a custom
tag. Although there can be more than one taglib
directive defined, the prefix must be unique.
• There are two attributes to consider :
> The Uniform Resource Identifier, or uri, describes the
set of custom tags associated with the prefix tag.
> The prefix is the name that precedes the custom tag
name. Empty prefixes are illegal, and the following
prefixes cannot be used because they are reserved
by Sun Microsystems: jsp, jspx, java, javax, servlet,
sun, and sunw.

35
Implicit Objects
• Currently the container provides nine predefined variables
with specified names that JSP-embedded Java can utilize. In
this section, we will cover each predefined variable, its
purpose, and functionality:

36
application
• The application object The application object is of the ServletContext
data type. It provides a set of methods to communicate with the container.
The web.xml file might look something like the following:
<context-param>
<param-name>paramName</param-name>
<param-value>paramValue</param-value>
</context-param>
Within the JSP or scripting code, you could access this information by making
the subsequent call:
application.getInitParameter(“paramName”);
These variables are analogous to creating static global variables for your web
application.

37
pageContext
• The pageContext object provides the JSP with information about the
current request, also known as its page attributes.
• .PageContext abstract class provides the following convenience methods
to access other implicit objects from the pageContext:
 getOut()
 getException()
 getPage()
 getRequest()
 getResponse()
 getSession()
 getServletConfig()
 getServletContext()
• It also provides methods for forwarding, inclusion, and error handling:
• forward() include() handlePageException()

38
config
• The config object is of the ServletConfig data type.
• It enables the container to pass information to the JSP
page before it is initialized.
• The scope of the config object is limited to the page.

39
request
• The request object is bound to the ServletRequest interface,
meaning its data is accessible through the getAttribute(String
name) method.
• Technically, a new request object is created for the client
request and destroyed when a response is generated. Even if a
forward(…) or include(…) is performed, the request object is
still in scope.

40
response
• The response object is an instance of the implementation-
specific subclass of the javax.servlet.ServletResponse
interface, often known as HttpServletResponse.
• Unlike servlets, it enables HTTP status codes and headers
in the JSP to be changed after output has been sent to
the client. This is due to the output stream being buffered
(assuming the page directive buffer attribute is not set to
none).
• The response object has a page scope, which means it is
bound to the PageContext and can be accessed directly
within the _jspService(…) method—a period more
commonly referred to as the life of the current request.

41
session
• This object is referenced by the session object and is available
as long as session=false is not defined with a page directive.
• By using the getAttribute(String name) method, you can retrieve
data stored in an object by passing in a specified name.
• This object has a session scope, which means it exists for the
life of the session and is bound to the PageContext.
• A session object is usually useful for getting a unique ID
associated with the entire transaction

42
out
• The out object is used to write response information to the
client.
• It is of the class javax.servlet.jsp.JspWriter, which is a buffered
version of the java.io.PrintWriter class.
• The buffered size can be configured by using the buffer
attribute in the page directive.
• For example:
• <%@ page buffer=”16kb” %>

43
page
• The page object is similar to the this keyword in Java.
• It represents an instance of the servlet generated by the JSP
page for the current request.
• The page object exists for future use when another language
can be specified by using the language attribute of the page
directive.
• Until then, it isn’t used much. When used in the future, it is
important to know it has a page scope.

44
exception
• The exception object is an instance of the java.lang.Throwable
class.
• It represents the uncaught Throwable object that results in the
error page being invoked. Let’s say an uncaught exception is
encountered during request processing, for example, a
RuntimeException .
• you could use the implicit exception object within the error
page to print out a stack trace.

47
Page scope
• An object with a page scope is available only within the current page.
It can be accessed directly within the _jspService(…) method or
indirectly with any custom methods (provided there is a method that
returns a handle to the object) of the originating JSP page

48
Request scope
• An object with a request scope is accessible from all pages
processing the same request. This includes dispatched requests. If a
request is transferred by using either of the RequestDispatcher
methods include(…) or forward(…), the component is in scope

49
Session scope
• Objects with a session scope are available for the life of the
session. Until the session is closed manually or automatically
due to a method call or a timeout, components can exist and
share data.

50
It is also important to understand the
life cycle of implicit objects in order
to know how and when to use them.

51
Expression <%= … %>
• Expressions are evaluated at HTTP processing time or
when the HTTP server processes the request.
• Expressions are left unprocessed until the buffer is written
out to the client, meaning all implicit objects have been
initialized and are available.
• <%= locateClient(request) %>

52
Scriptlet <% … %>
• Scriptlets are executed at request-processing time and
embedded within the _jspService(…) method. This means all
implicit objects have been initialized and can be accessed
directly.
<% out.print("Tomorrow or the next life,” + “whichever comes first"); %>

53
Declarations
• Declarations are initialized when the JSP’s jspInit() method is
invoked. Its methods however, are available outside the
_jspService(…) method. In order to access implicit objects,
they must either be passed as a parameter, or there must be
an available servlet method which provides a reference to the
instance.
<%!
public String locateClient(HttpServletRequest req) {
ServletConfig config = getServletConfig();
return req.getRemoteHost();
}%>

54
Directive <%@ … %>
• Directives are invoked at translation time.
• When another page is included into the current page, its contents
are inserted in the _jspService(…) method.
• The code for the included file is added to the code of the calling
JSP page, right where the include directive is placed.
• Consequently, all the implicit objects are available to the code of
the included page. Consider the following example:

55
Implicit objects are a key feature to
providing a JSP with all the functionality
available to a servlet.
For greater functionality a JSP
can use “actions”
to invoke a behavior.

56
Actions
• Actions are Java tags that affect the runtime
behavior of the JSP. In this section, we will go
through each of the following actions by discussing
its purpose and syntax, and providing examples:
• jsp:include
• jsp:forward
• jsp:plugin
• jsp:param
• jsp:useBean
> jsp:setProperty
> jsp:getProperty

57
jsp:include
• This tag enables you to include either a static or dynamic resource.
> If static, the content of the resource is included in the JSP page.
> If dynamic, the request is sent and returned with a result included in the
JSP page. After the action is finished,the JSP container continues to
process the rest of the JSP page.
• An included page can access only the JspWriter object. It cannot
set headers or set cookies. Calls to related methods will be
ignored.

58
• Inclusion is processed at request time. Each attribute is evaluated
and parameters set, if necessary. The include tag has three
attribute types that can be used:
> The page tag defines the relative URL of the target source.
To include multiple pages within a page, you must provide a
separate jsp:include action for each.
> The param tag identifies any parameter values that need to
be passed to the target.
> The flush tag is equal to either true or false. A true value
signifies that the page output is buffered and flushed prior to
being returned to the original JSP. A false value means the
buffer is not flushed. The default value is false.

59
jsp:forward
• Like the jsp:include, the forward action transfers control of the
current request handler to a specified resource.
• The target source is then responsible for generating the
response. Similar to the RequestDispatcher’s forward(…)
method, all buffered output is cleared when the
request/response object is sent.
• If the output has already been flushed, the system throws an
exception.
• The target source can be quite flexible. It can be an HTML file,
another JSP page, or a servlet, assuming all share the same
application context as the forwarding JSP page.
• After a forward action is invoked, execution of the current page
is terminated.
• Any lines after the jsp:forward block are not processed.

60
The following rules apply to the output
stream associated to a jsp:forward
action:
• If the page output is buffered, the buffer is cleared prior to
forwarding.
• If the page output is buffered and the buffer was flushed,
an attempt to forward the request will result in an
IllegalStateException.
• If the page output was unbuffered and anything has been
written to it, any attempt to forward the request will result
in an IllegalStateException.

61
jsp:plugin
• When creating web applications, you might need to
include Java plug-in software to enhance the graphical or
functional behavior.
• The plugin action,defined as jsp:plugin, displays or plays
an applet or bean in the browser.
• The plug-in is either built into the browser or downloaded
from a specific URL.

62
The jsp:plugin element is made up of four parts:
• mandatory attributes
• optional attributes
• jsp:params tag
• jsp:fallback tag.

65
The jsp:plugin action has two sub-elements:
• jsp:params : allows parameter names and values to be
passed to the object.
• jsp:fallback : displays a text message for the user if the plug-
in cannot be started. If it manages to start, but the bean or
applet cannot, then a pop-up dialog appears to explain the
problem.

66
param action
• A param action is used to provide a name/value pair to a
servlet. It is used in conjunction with the jsp:include,
jsp:forward, and jsp:params actions.
• A translation error occurs if the element is used elsewhere.
• New values take precedence over existing values and are scoped
within the include or forward page.
• Syntax
• For a single parameter:
• <jsp:param name=“parameterName” value=“paramterValue” />
• Example
• <jsp:param name=“ssn” value=“555-55-5555” />

67
jsp:useBean
• A powerful feature of Java Server Pages is the ability to
incorporate JavaBeans within a page.
• These methods perform all the necessary business logic
to arrive at the appropriate result. they have the ability to
have their attributes changed dynamically.
• Through reflection, the container can determine which
attributes are visible and changeable.

68
Attributes
1. Id :
• Specifies the name of the bean.
• If a bean scope extends beyond the current page, it can be
saved.
• If the bean instance does not exist, a new bean is created.
• This variable is case sensitive.
• The name must be unique within the translation unit. Duplicate
IDs will result in a fatal translation error.

69
2. scope Specifies the extent of the bean’s visibility. There
are four options to choose from: page, request, session,
or application.
 page scope :
> The bean variable is stored as an instance variable.
> Within the page, the bean is used once and then
destroyed.
> You can use the bean within the JSP page or any of the
page’s static include files. This means files acquired via
the include directive are within scope, while pages
acquired from the include action are not in scope.

70
request scope : The bean instance is stored as a request attribute.
• This means the bean can be used from any JSP page processing the same
request.
• Whereas a page scope ends at the onset of a jsp:forward action, a request
scope keeps the bean alive through jsp:forward and jsp:include actions.
• When the response is returned, the bean is destroyed.
session scope : The bean instance is stored as the user’s session
attribute. Consequently, the bean exists across the entire session. If the client
disconnects, the bean will be made available when the client reconnects.
• By default, the session attribute is true. If a JSP is defined to not participate in
a session via the <%@ page … %> directive, and attempts to, a fatal
transaction error will occur.
application scope :The bean instance is stored as a servlet context attribute
and therefore available to the entire application.

71
3. Class : Specifies the class name of the bean.
> When the bean is constructed,the server uses the fully
qualifying class name to generate the instance. If the bean
already exists, the class name is not necessary.
4. Type : Defines the class type used to cast the bean to its
appropriate data type.
> When the object is retrieved from a particular scope, it is
returned as a generic object. The bean is then cast to the
class type defined. If the type is not defined, the value
defaults to the same type as that defined by the class
variable.
> If they do not match, a ClassCastException is thrown. By
providing a type attribute without class or beanName
attributes, you can give a local name to an object defined in
another JSP page or servlet.

72
5. beanName :Replaces the class attribute to create the bean
instance. This value is passed as a parameter to the
java.beans.Beans.instantiate(…) method to create the
instance.
• It enables developers to dynamically create the bean,
because the attribute can accept a request-time attribute
expression as a value.
• It is not valid to provide both class and beanName.
Example
<jsp:useBean id=“tax” class=“com.eei.TaxBean” scope=“application” />

74
There are two major advantages of using
JavaBeans within a JSP.
• first is the ability to set attributes
• second is the ability to define the scope of the bean.
• While we have discussed the latter, we now need to
address the technique used to set properties within the
bean.

75
jsp:setProperty
• The most significant feature of a bean is its property values.
• The bean’s “get” and “set” methods are designed to change
these values through reflection.

78
• Not all bean properties are Strings; consequently, you need to
know how the container manages bean properties of other data
types. When the client sends a request, the parameter values are
always of type String.
• These values are converted to their appropriate data types when
stored in the bean’s property.
• The JavaBeans specification states that the setAsText(String
name) method should be used on a property if it has a
PropertyEditor class.
• If a conversion failure occurs, an IllegalArgumentException is
thrown.
• By default, PropertyEditors are provided for all primitive and
respective wrapper classes. If the property is of a data type that
is not available, the String will get converted to that of type
Object.

79
jsp:getProperty
• When retrieving a bean’s property, it is converted to a String by
using either the toString() method or the wrapper class
valueOf(String str) method if it is a primitive.
• Once converted, the results are passed to the output stream
and finally to the client.
Hello Yoav!

80
Here are some points to consider:
• You must first create an instance of the bean by using the
jsp:useBean element before calling the jsp:getProperty tag.
• The jsp:getProperty tag works on JavaBeans, but not on
enterprise beans. You could, however, have your JSP tag
communicate with a JavaBean, which communicates with an
enterprise bean. It’s a fair workaround.
• If you use the jsp:getProperty tag on a property whose value is
equal to null, a NullPointerException is thrown. If you are using a
scriptlet or expression to retrieve this value, the null keyword is
returned instead.
• You cannot use jsp:getProperty to retrieve values of an indexed
property. An indexed property is an object that is either a
collection or array.

SCWCD : Java server pages CHAP : 9

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to SCWCD : Java server pages CHAP : 9 (20)

More from Ben Abdallah Helmi (20)

Recently uploaded (20)

SCWCD : Java server pages CHAP : 9