APPENDIX D
OVERVIEW OF JSP, JSTL, and
EL TAGS
1
OVERVIEW OF JSP, JSTL, and EL TAGS
This appendix describes how to create and modify JSP pages in JD. It
provides an introduction to JavaServer Pages (JSP), basic JSP tags,
custom library tags, JD's JSP Standard Tag Library support (JSTL), JSP
development requirements, and how to develop JSP pages using JD.
2
Basic JSP Tags
A JSP tag is a piece of code that encapsulates a repeatable process
(coded in Java) and serves as a small program within a JSP page. Its
purpose is:
• To reduce redundant code
• To increase code legibility
• To provide features that can be applied to multiple JSP pages with
minimal alteration.
JSP tags use a tag syntax similar to other tag languages such as HTML.
They are bracketed by "< >" symbols, and may have attributes that
supply information to the tag and customize its behavior for a particular
requirement.
3
Basic JSP Tags
Two kinds of files have a .jsp extension, and both can be created using
JD:
• JSP page
Contains HTML and JSP tags and uses JSP tag syntax (we will
concentrate on this type file).
• JSP 1.2 document
An XML file with a .jsp extension containing XML tags and
normal JSP and HTML tags.
4
Where to Put the Code?
The preferred location for application logic is within a centralized later
or business services layer. This makes the code more maintainable and
reusable.
5
Beginning and Ending Tags
When using JSP, JSTL, or EL tags, you need to provide an ending tag for
each starting tag. The ending tag is coded using one of the following
syntax examples:
• <tag>body of tag</tag>
• <tag></tag>
• <tag />
(this ends the tag within the starting tag)
6
Processing of Standard Tags
How code is processed (compiles into a servlet and rendered in HTML)
depends on the type of tag. All JSP tags can be categorized as one of the
following types:
• Scripting elements
• Directives
• Actions
7
Scripting Elements
Scripting elements are tags that the JSP container converts to Java code
in the servlet that it generates from the JSP file. There are three kinds of
scripting elements:
• Expressions
• Scriptlets
• Declarations
8
Expressions
Produce values that are output directly in the HTML page and have the
following format:
<%=
expression
%>
The expression will be embedded inside a print statement in the servlet
and can be as simple as a hard-coded value or mathematical expression
like:
<%= 450 %>
(displays “450”)
<%= 50*6 %>
(displays “300”)
More often, the expression will be a return value from a Java method call
or a variable value such as:
<%= new java.util.Date() %> (displays curerent date)
<%= salAmount %> (displays value of salAmount)
9
Scriplets
Scriplets are snippets of standard Java code that you want the JSP
container to insert into the servlet. They are designated using the
delimiters "<% %>", as follows:
<% Java code; %>
This code is (inside the delimiters) is embedded into the Java servlet
when the JSP page is translated. Scriptlets must be complete Java code
statements (syntax errors are caught when compiled). Scriplets are used
when you want to do something, such as loops and conditional tests, JSP
tags cannot do.
10
Scriplets
The following example shows how to do a conditional test of a Java int
variable:
<%
int salAmount = 3000;
if (salAmount > 0) {
%>
<h2>The salary is positive.</h2>
<%
}
else {
%>
<table border=“1”>
<tr align=“center”>
<td><b>Warning!</b></td>
</tr>
<tr align=“center”>
<td>Salary is negative or zero.<br />
Contact your Financial Advisor.
</td>
</tr>
</table>
<%
}
%>
The space between
br and the / is
required.
11
Scriplets
Output if the salAmount is positive:
Output if the salAmount is zero or negative:
12
Scriplets
Sometimes expressions and scriplets can be used for the same purpose.
The following two tags will each display the same amount in the HTML
page:
<%= salAmount %>
<% out.println( salAmount); %>
Scriplets are best used where there is a unique logic requirement for a
JSP page. The do not promote the idea of reusable code because they
are written specifically for a single JSP page. If you use a large scriplet in
more than one JSP page, you should consider embedding the logic in a
class that can be called from a scriplet or in a custom JSP tag.
See NOTE topic in text (page 750).
13
Declarations
The JSP container inserts expressions and scriplets into the
_jspService() method of the servlet. This method is called automatically
when the JSP page is run. If you want to insert code outside this
method, you can use a declaration, which is delimited by "<%! %>"
symbols. As with scriplets, You also need to use valid Java code!
Declarations do not cause any output in the browser. They are intended
to generate Java code inside the class file but outside of the
_jspService() method.
Declarations are useful when you need to declare a servlet-specific
method that you will call once in scriplets or expressions.
14
Declarations
For example, the following would create code for a method in the servlet
class that is outside of the _jspService() method:
<%!
public static double calcRaise( int salary ) {
return ( salary * 1.3 );
}
%>
The above method can be called from any expression or scriplet inside
the JSP page, for example:
<%= calcRaise( empSalary ) %>
You can also declare class variables (that are outside of any method) in
the same way. By combining scriplets and declarations, you can add
almost any type of code to the servlet class file.
15
Types of Comments
A Java comment inside scriplet tags will appear in the Java servlet file.
For example, the scriplet "<% // this is a comment %>" will be
written as "// this is a comment" into the Java code. You can also use
the multi-line comment "/*" and "*/" the same way.
The JSP file can contain a JSP comment (also called a page comment)
that is not copied into the servlet file. It is used only for documentation
in the JSP file. JSP comments use the delimiters "<%-- --%>".
You can embed HTML comments using the normal HTML form
"<!-- -->" which will appear in the browser's View Source window. The
JSP container prints all HTML (including HTML comments) using a call
to out.write().
16
Types of Comments
You can dynamically generate an HTML comment by embedding an
expression within the comment using the format:
"<!-- static comment <%= expression %> static -->"
17
Scripting Elements in the Servlet
When the JSP container creates the Java servlet from the JSP file, it
transforms the JSP tags into pure Java. Different types of scripting
elements appear differently in the servlet. For example, consider the
following code (from a JSP page called DemoTag.jsp):
18
Scripting Elements in the Servlet
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
<!-- Salary display -->
<%-- scriptlets --%>
<%
int salAmount = 3000;
if (salAmount > 0) {
%>
<h2>The salary is positive.</h2>
<br>
<%
out.write("The new salary is " + calcRaise(salAmount));
%>
<%
}
else {
%>
<h1>The salary is
<%-- expression --%>
19
Scripting Elements in the Servlet
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
<%= salAmount %>
</h1>
<%
}
%>
<br>
<%// expression %>
<%= "Salary is " + salAmount %>
<%-- declaration --%>
<%!
public static double calcRaise(int salary) {
return(salary * 1.3);
}
%>
20
Scripting Elements in the Servlet
The JSP container will convert this JSP code to Java code in a servlet file
called DemoTag.java. It will also compile the Java file into a .class file.
The JSP page corresponds to the following lines in the Java servlet. The
line numbers refer to the lines in the JSP file that was the source for the
code. The "\n" symbol creates a new line in the HTML page. Notice
that lines 2 and 17 do not appear in the servlet because they are page
comments that do not create code outside of the JSP page.
21
Scripting Elements in the Servlet
01: out.write("<!-- Salary display -->\n"):
04: int salAmount = 3000;
05: if (salAmount > 0) {
07-08:
out.write("<h2>The salary is positive.</h2>\n<br>\n");
10:
out.write("The new salary is " + calcRaise(salAmount));
13: }
14: else {
16:
out.write("<h1>The salary is \n");
18:
out.print( salAmount );
19:
out.write("\n</h1>\n");
21: }
24: out.write("<br>");
25: // expression
26: out.write("\n");
27: out.print( "Salary is " + salAmount );
28: out.write("\n");
30: public static double calcRaise(int salary) {
31:
return(salary * 1.3);
32: }
22
Scripting Elements in the Servlet
Lines 01-27 are written into the _jspService() method. Lines 30-32
appear in the servlet before the _jspService() method because the JSP
lines that created them were written inside a declaration tag. The code
uses both out.print() and out.write() to output text into the HTML that
is displayed in the browser. Both methods are equivalent.
This converted code reflects the following rules for the different types
of JSP code:
• Scriplets are written as Java code into the _jspService() method.
• Expressions are embedded into out.write() Java statements.
• Declarations are written as Java code outside the _jspService()
method.
• Page comments are not copied into the servlet file.
23
Scripting Elements in the Servlet
Viewing the source on the HTML page that this JSP produces, displays
the following:
<!—Salary display -->
<h2>The Salary is positive.</h2>
<br>
The new salary is 3900.0
<br>
Salary is 3000
Neither page comments ("<%-- --%>") nor Java comments
"<%// %>") are displayed in the HTML page or in the View Source
window.
24
Directives
The directive tag allows you to affect the structure of the Java servlet
that is generated from the JSP file. A directive has the format
"<%@directive_name%>" where "directive-name" is:
• page
• include
• taglib
25
page
This directive is used to specify file-level commands such as the imported
classes or the page content type. Here are some examples:
<%@ page contentType="text/html;charset=windows-1252" %>
<%@ page import="java.util.*, oracle.jbo.*" errorPage="errorpage.jsp" %>
The first one specifies to the servlet the type of content—in this case,
HTML ("text/html"). This generates the following servlet line in the
_jspService() method:
response.setContentType( "text/html;charset=windows-1252" );
The second line specifies the addition of the following to the servlet
import section:
import java.util.*;
import oracle.jbo.*;
26
page
It also designates which file will be displayed if an error occurs. The
errorPage attribute adds the page name to the assignment of the
pageControl variable in the servlet's _jspService() method, as shown
below:
PageContext pageContext =
JspFactory.getDefaultFactory().getPageContext(
this, request, response,
"errorpage.jsp", true,
JspWriter.DEFAULT_BUFFER, true );
27
include
This directive inserts the text from another file (for example, a JSP or
HTML page) into the generated file. This is useful for a design element
that will be shared by many pages. The following example inserts the
output of a JSP file:
<%@ include file="TimeInfo.jsp" flush="true" %>
The TimeInfo.jsp file contains the following:
<!—Current Time is here -->
<br>The current time is: <%= new java.util.Date() %></p>
The JSP container inserts the entire file into the main JSP page before it
is translated into a servlet.
28
include
The code from the included file (the .jsp file above) is embedded into
the servlet that is generated from the JSP page and therefore does not
need to be compiles as a separate file. The included file is not run along
with the main JSP page and does not need to be present at runtime. The
source code to be included must be present at compile time.
If the included file is changed, the JSP page must be recompiled. A
compile error will occur if the included source file is not available.
Another way to include a page inside another page is by using the
<jsp:include /> tag. Technically it is an action tag, but accomplishes the
same thing.
29
taglib
This directive specifies the name (alias) and location of the tag library
descriptor (.tld) file – an XML file containing a list of tags, their
attributes, and the classes that implement the tags. The uri (uniform
resource identifier) attribute identifies the location of the tag library
definition. The prefix attribute provides an alias for the tag library used
in action tags. Here is an example:
<%@ taglib uri="/WEB-INF/struts-html.tld” prefix=“html” %>
30
taglib
There is no corresponding code generated in the servlet for the taglib
directive. However, the JSP container looks in the tag library identified in
the tag for information about the class names of the action tags that are
used in the JSP page. For example, the JSP page might have a call such as
the following:
<html:form action=“/Dept.jsp.do”>
31
taglib
The JSP container looks in the tag library definition file identified by the
prefix “html" specified in the taglib for a reference to the class and path
that represents the form tag (here, using the FormTag.class). It the
generates code in the _jspService() method to instantiate the class (the
form tag in the JSP page) and pass it parameters based on the attributes
of the tag.
32
Actions
Actions specify a component from a tag library or a standard tag. They
may display output in the HTML page or write code into the servlet
without showing output. The syntax for an action tag includes the tag
prefix and the name of the action component as follows:
<prefix:action_name attribute=value />
The tag_name is the actual tag used in the code and the tag has
attributes with values. It is mapped to a Java class in the tag library as
mentioned earlier and as shown in this example used earlier:
<html:form action=“/Dept.jsp.do”>
Much of the work done in JD with JSP pages uses action tags like above
for the components.
33
Other Standard Action Tags
JSP pages support a set of standard action tags. The JSP container needs
to have CLASSPATH information that points to the core JSP JAR files.
Standard tags use to prefix "jsp", which is automatically known by the
JSP container and needs no taglib directive. Following is a brief
description of the standard action tags:
34
<jsp:fallback>
This tag must appear inside a plugin action tag (described later). It
defines what will happen if the plugin fails to load. The example below
loads the CalcErrorLoad.html page if the CalcSalary applet cannot be
started:
<jsp:plugin type=applet code="CalcSalary.class" >
<jsp:fallback>
http://www.download.com/CalcLoadError.html
</jsp:fallback>
</jsp:plugin>
35
<jsp:forward>
This tag passes a request to another JSP page, servlet, or HTML file. The
target location may be an expression that is dynamically loaded by other
actions or Java code. The request may include parameters and values.
Here is an example:
<jsp:forward page="EmpCalc.jsp" />
36
<jsp:getProperty>
This tag returns the value of a bean property. The bean must be used
before this tag (for example, using a useBean action) so that it has been
instantiated. In this example, the value property of the item called
"newItem" will be printed on the page:
<jsp:getProperty name="newItem" property="value" />
37
<jsp:include>
This tag embeds a file inside the JSP page at runtime. Unlike the include
directive the include file (JSP or HTML) does not need to be available
when the main JSP page is compiled. However, it does need to be
available when the main JSP page is run. If it is a JSP page, it needs to be
compiled for the main JSP page to run correctly. Butif the included JSP
page is not compiled, compilation will occur when the main JSP page is
run. For example:
<jsp:include page="TimeInfo.jsp" flush="true" />
This tag can specify a page dynamically if you embed an expression in
the page attribute. This functionality is not possible with the include
directive. For example, you assign the page file name to a variable
includePage based upon some condition. The include tag looks like:
<jsp:include page="<%= includepage %>" flush="true" />
38
<jsp:param>
This tag specifies a name/value pair that is embedded in (and must
appear within) the fallback, include, and params tags. The params tag
description contains an example of the param action
39
<jsp:params>
This action, like the fallback action, can only occur inside of a plugin
action tag. It surrounds the <jsp:param> actions inside a plugin block.
For example:
<jsp:plugin type=applet code="CalcSalary.class" >
<jsp:params>
<jsp:param name="id" value="101" />
<jsp:param name="name" value="Tiger" />
</jsp:params>
</jsp:plugin>
40
<jsp:plugin>
This tag runs an applet or bean that may require a browser extension
(plugin). The JSP engine returns an HTML tag ("embed" for Internet
Explorer or "object" for Netscape). A number of attributes specify the
plugin name, the type (bean or applet), the size of the display window,
the directory that contains the plugin, and so on. Here is a short
example:
<jsp:plugin type="applet"
code="ShowSalary.class" codebase="/devices/"
name="MainSalaryDisplay" align="bottom"
height=400 width=600>
</jsp:plugin>
41
<jsp:setProperty>
This tag, like the getProperty tag, works with beans. It assigns the
property of an existing bean object. The object must be instantiated
before you call the setProperty tag. Here is an example that sets the
value property of the newItem object to "Harry":
<jsp:setProperty name="newItem" property="value"
value="Harry" />
42
<jsp:useBean>
This tag allows you to make a Java class available inside the JSP file. You
can pass attributes to the object to alter its functionality and define its
use.
For example:
<jsp:useBean id="fileBean" scope="page"
class="oracle.jsp.webutil.fileaccess.HttpUploadBean">
</jsp:useBean>
43
An Action Tag Example
Here is an example of a JSP action tag used to specify an HTML form
that is processed by the Struts controller:
<html:form action="/Dept.jsp.do">
44
Summary of JSP Tag Delimiters
The following summarizes the tag format shown in this section:
Type of Tag
Actions
Declaration
Directive
Expression
Page comment
Scriplet
Format
<prefix:action_name
<%!
%>
<%@ directive_name
<%=
<%-<%
/>
%>
%>
--%>
%>
45
Simple JSP Project
Go to the Handouts links, download, and unzip the project.
46
An Action Tag Example
JSP (LocEdit.jsp)
<%@ taglib
uri="/webapp/DataTags.tld"
prefix="jbo" %>
<jbo:ApplicationModule definition="LocJSP.Locbc4jModule" id="locAM" releasemode="Stateful" />
Class Library JAR (datatags.jar)
Tag Library Definition (DataTags.tld)
<tag>
<name>ApplicationModule</name>
<tagclass>oracle.jbo.html.jsp.
datatags.ApplicationModuleTag
</tagclass>
<attribute>
<name>id</name>
<required>true</required>
</attribute>
. . .
47