JSP 2.0 and JSTL:
Principles and Patterns
The J2EE Presentation Tier
Four key questions to answer today:
What justifies JSP 2.0?
What are its major new features?
What is JSTL?
What do these new technologies suggest
about development patterns and best
practices?
Crash course on the J2EE
Presentation Tier
J2EE
JSP
JSTL
Servlets
Current standards:
JSP 1.2
Servlet 2.3
JSTL 1.0
In a few months:
JSP 2.0
Servlet 2.4
JSTL 1.1
JSTL
Crash course on the J2EE
presentation tier
Servlets
Java classes that handle requests by
producing responses (e.g., HTTP requests
and responses)
JavaServer Pages (JSP)
HTML
-
like pages with some
dynamic
content.
They turn into servlets automatically.
JSP Standard Tag Library (JSTL)
Set of standard components for JSP.
It is used inside JSP pages.
Organization of the platform
Your application
Java language
Java Servlet API
JavaServer Pages (JSP)
JSTL
Your
web pages
What kinds of things go in
JSP pages?
Scriptlets
<%
getFoo(request);
printFoo(out);
String a = ”goat”;
%>
<% if (a.equals(”pig”) {%>
Oink!
<% } %>
Java (and more?)
embedded within
template text
Access to
implicit
objects
: request,
response, etc.
Conditional blocks,
loops
—
manually
constructed
What kinds of things go in
JSP pages?
Tag libraries
<foo:bar/>
<c:if test=”${
c
}
”
>
c
is true
</c:if>
<c:forEach>
Round and round
we go
</c:forEach>
XML tags
Invoke Java logic
behind the scenes.
May access body, e.g.,
for iteration, conditional
inclusion
—
or just as
arbitrary parameter
May access
PageContext
Libraries and prefixes
Question 1
Why JSP 2.0?
(Or, what’s wrong with the current
version of JSP?)
Why we like JSP in the first
place (
)
Open standard with support from
many vendors
The performance and scalability of
servlets (for JSP pages compile into
servlets)
Extensibility (custom tags)
Easy integration with other J2EE and
Java technologies (Servlets, EJB)
What’s irritating about JSP?
(
)
The tag
-
extension protocol is too
complicated
Tag handler
doStartTag()
doEndTag()
doCatch()
doFinally()
doInitBody()
doAfterBody()
release()
What’s irritating about JSP?
(
)
Also, tags don’t support certain kinds
of code reuse.
<font color=”
<%=statusColor%>
”>
<% for (…) { %>
<%= customer %>
:
<%= hatSize %>
<% } %>
</font>
out.println(…);
for(…) {
out.println(…);
…
}
What’s
bad
about JSP?
(
)
The general consensus says…
Scriplets
They complicate abstraction and code
reuse.
They make it harder for
nonprogrammers to maintain pages
Question 2
What new features does JSP 2.0
offer?
(Or, how does it fix the issues we just
raised?)
How does JSP 2.0 address
these issues?
Expression language
Tag files
Simplified Tag API (SimpleTag versus Tag)
Improved XML syntax
Also, though it’s not really part of JSP,
JSTL improves things too.
The end result:
JSP pages become easier to write and maintain.
The JSP Expression Language (EL):
Goals and principles
The major goal: simplicity.
The language should be usable by
nonprogrammers.
Inspirations: JavaScript, XPath
But it’s much simpler than even these basic
expression languages.
•
Quick: what does
//foo = ‘bar’
mean in XPath?
•
Or what happens with
age + 3
in ECMAScript?
XPath (
//foo = ‘bar’
)
“If one object to be compared is a
node
-
set and the other is a string,
then the comparison will be true if and
only if there is a node in the node
-
set
such that the result of performing the
comparison on the
string
-
value
of the
node and the other string is true.”
ECMAScript (
age + 3
)
Page 62 of
188
:
The Addition operator ( + )
The addition operator either performs string concatenation or numeric addition.
The production
AdditiveExpression
:
AdditiveExpression
+
MultiplicativeExpression
is evaluated as
follows:
1. Evaluate
AdditiveExpression
.
2. Call GetValue(Result(1)).
3. Evaluate
MultiplicativeExpression
.
4. Call GetValue(Result(3)).
5. Call ToPrimitive(Result(2)).
6. Call ToPrimitive(Result(4)).
7. If Type(Result(5)) is String
or
Type(Result(6)) is String, go to step 12. (Note that this step differs
from step 3 in the comparison algorithm for the relational operators, by using
or
instead of
and
.)
8. Call ToNumber(Result(5)).
9. Call ToNumber(Result(6)).
10. Apply the addition operation to Result(8) and Result(9). See the note below (11.6.3).
11. Return Result(10).
12. Call ToString(Result(5)).
13. Call ToString(Result(6)).
14. Concatenate Result(12) followed by Result(13).
15. Return Result(14).
29. One
-
half of self
-
employment tax.
Attach Schedule SE.
30. Self
-
employed health insurance
deduction (see page 33)
31. Self
-
employed SEP, SIMPLE, and
qualified plans
32. Penalty on early withdrawal of savings
33. Alimony paid
34. Add lines 23 through 33a
35. Subtract line 34 from line 22. This is
your adjusted gross income.
The JSP Expression
Language (EL): Key syntax
Expressions appear between
${
and
}
.
Note that
${
and
}
may contain whole expressions, not
just variable names, as in the Bourne shell (and its
dozen derivatives.)
E.g.,
${myExpression + 2}
Expressions’ default targets are
scoped
attributes
(page, request, session,
application)
${duck}
≡
pageContext.findAttribute(“duck”)
The JSP Expression
Language (EL): Key syntax
The
.
and
[]
operators refer to
JavaBean
-
style properties and Map
elements:
${duck.beakColor}
can resolve to
((Duck) pageContext.getAttribute(”duck”)).getBeakColo
r()
Note the automatic type
-
cast.
This is one of the great features of the EL: users do not
need to concern themselves with types in most cases (even
though the underlying types of data objects are preserved.)
The JSP Expression Language
(EL): advanced data access
Expressions may also refer to
cookies, request parameters, and
other data:
${cookie.crumb}
${param.password}
${header[“User
-
Agent”]}
${pageContext.request.remoteUser}
The JSP Expression
Language (EL): more syntax
The EL supports
Arithmetic
${age + 3}
Comparisons
${age > 21}
Equality checks
${age = 55}
Logical operations
${young or beautiful}
Emptiness detection
${empty a}
•
‘a’ is empty String (“”), empty List, null,
etc. Useful for
${empty param.x}
The JSP Expression
Language: Uses
JSTL 1.0 introduced the EL, but it
could be used only within tags.
In JSP 2.0, it can be used almost
anywhere
<font color=”
${color}
”>
Hi,
${user}
.
You are <user:age
style=”
${style}
”/>
years old.
</font>
Tag Files: nature and
purpose
Solve difficulty of reusing text/HTML
within a tag.
And makes it much easier to write
simple tags, since you can do so in
JSP instead of Java.
Stand
-
alone file with
<%@ tag %>
directive instead of traditional
<%@ page %>
directive.
JSP 2.0 tag files
<%@ tag name=”tableTag” %>
<%@ attribute name=”items” %>
<table width=”…” bgcolor=”…”>
<th>
<td>Name</td>
<td>IQ</td>
</th>
<c:forEach var=”i” items=”${
items
}”>
<tr>
<td>
${i.fullName}
</td>
<td>
${i.IQ}
</td>
</tr>
</c:forEach>
</table>
Using the new tag…
Your shopping cart:
<my:tableTag items=”${cart}” />
Your wish list:
<my:tableTag items=”${wishList}” />
Things we want you to buy:
<my:tableTag items=”${pressuredSales}” />
Old tag handler
Tag handler
doStartTag()
doEndTag()
doCatch()
doFinally()
Tag
attributes
Tag
body
doInitBody()
doAfterBody()
release()
SimpleTag handler
Tag handler
Tag
attributes
Tag
body
(no
scriptlets)
doTag()
JSP 2.0:
Improved XML syntax
Old style: JSP as document
New style: JSP as namespace
Other changes
<jsp:element>
,
<jsp:attribute>
•
Avoids
<a href=”
<c:url value=”…”/>
”/>
<jsp:root>
xmlns:jsp=“http://java.sun.com/JSP/Page”
Question 3
What is JSTL? What features does it
offer?
JSTL design principles
JSTL 1.0: Keep it simple!
Targeted tags
Could have a single <go> tag:
•
<go action=“forEach”
argument1=“${myData}”>
Instead, single
-
purpose tags, tightly
focused
Design intended for page author
Perhaps something of a fantasy, like the legal “reasonable
person.” But a helpful guide nonetheless.
JSTL 1.0 features
Control flow
Iteration, conditions
URL management
Retrieve data, add session IDs
Text formatting and internationalization
Dates and numbers
Localized messages
XML manipulation
XPath, XSLT
Database access
Queries, updates
JSTL 1.0 libraries
Library features
Recommended prefix
Core (control flow,
URLs, variable access)
c
Text formatting
fmt
XML manipulation
x
Database access
sql
JSTL features:
managing variables
Outputting values with EL
<c:out value=”${user.IQ}” />
Storing data
<c:set var=”user”
scope=”session”>
// arbitrary text
</c:set>
Note the use of “var” and “scope”: a JSTL convention
JSTL features:
iteration
Iteration
<c:forEach items=”${list}”
begin=”5” end=”20” step=”4”
var=”item”>
<c:out value=”${item}”/>
</c:forEach>
“
paging
”
JSTL features:
conditional logic
Conditional evaluation
<c:if test=”${a == b}”>
a equals b
</c:if>
Mutually exclusive
conditionals
<c:choose>
<c:when test=”${a == b}”>
a equals b
</c:when>
<c:when test=”${a == c}”>
a equals c
</c:when>
<c:otherwise>
I don’t know
what
’a’
equals.
</c:otherwise>
</c:choose>
JSTL features:
URL management
Retrieving data
<c:import var=”cnn”
url=”
http://www.cnn.com/cnn.rss
”/>
Data exposed as String or Reader
All core URLs supported (HTTP, FTP, HTTPS with JSSE)
Local, cross
-
context imports supported
Printing URLs
<c:url value=”/foo.jsp”>
Redirection
<c:redirect url=”/foo.jsp”>
JSTL features:
text formatting
Locale
-
sensitive formatting and parsing
Numbers
Dates
Internationalization
Message bundles
Message argument substitution
“Hi {0}. I would like to {1} your money today.
I will use it to buy myself a big {2}.”
<fmt:formatNumber type=“currency”
value=“${salary}” />
<fmt:message key=“welcome” />
JSTL features:
XML manipulation
Use of XPath to access, display
pieces of XML documents
<c:import url=”
http://www.cnn.com/cnn.rss
” var=”cnn”/>
<x:parse xml=”${cnn}” var=“dom”>
<x:out value=”$dom//item[1]/title”/>
Chaining XSLT transformations
<x:transform xslt=”${xsl2}” />
<x:transform xml=”${xml}” xslt=”${xsl}” />
</x:transform>
Advantages of JSTL
XML/XPath support
Why not always use XSLT?
JSTL integrates XPath with
convenient, standard access to
Java/JSP code.
•
E.g., parse an article URL out of a
document, then
follow the URL
and parse
its contents.
JSP/JSTL may be more familiar and
convenient for simple tasks.
•
Functional versus imperative
programming
JSTL features:
database manipulation
Queries (and ResultSet caching)
Updates / inserts
Transactions (
<sql:transaction>
)
Parametric (
PreparedStatement
) argument
substitution (
<sql:param>
)
DataSource
-
based connection management
<sql:query sql=“SELECT * FROM USERS”
var=“result” />
<c:forEach items=“${result.rows}”> … </c:forEach>
SQL tags: the debate
Tag
library
JSP
page
Back
-
end
Java
code
Database
Tag
library
SQL Tags:
The expert group’s conclusion
SQL tags are needed because…
many nonstandard offerings exist
it is not JSTL’s role to dictate a choice
of framework
•
As popular as MVC is, it’s not universal.
•
Even in an MVC application, not all data is worth
handling carefully.
prototyping is important
users ask for it!
The JSTL specification recommends
avoidance of SQL tags in large
applications.
JSTL programmer support
JSTL also supports Java developers
Simplifies tag development
IteratorTagSupport, ConditionalTagSupport
Instead of writing whole tag handler
(
doStartTag(),
doEndTag()
), simply override a
few methods:
•
protected boolean condition()
•
protected Object next()
Still, JSP 2.0 is probably easier.
•
Ugly JSP 1.1 tag protocol
Ugly JSP 1.1 tag
protocol with assistance from JSTL 1.0
Nice
JSP 2.0 tag protocol.
JSTL programmer support
JSTL API allows registrations of
defaults…
DataSource
Limit on size of results
Localization context (Locale, etc.)
Time zone
Question 4
How do the technologies work
together?
“Models” of JSP
development
Origin of the terms “model 1” and “model 2.”
JSP 0.92 spec:
“You can apply the JavaServer Pages
technology in two ways . . . Model 1: A request sent to a
JavaServer Pages file. . . . Model 2: A request sent to a Java
Servlet.”
JSTL works with either
model
Core tags, formatting tags are ideal
for applications that use either model.
XML
-
manipulation tags are on the
borderline. Ideally, they pull data out
of XML files that servlets or other
back
-
end logic sends them.
SQL tags are probably most useful in
model
-
1 applications.
Simple “model 2” example
public void doGet(HttpServletRequest request
HttpServletResponse response) {
// business logic that results in object ’data’
request.setAttribute(”d”, data);
sc.getRequestDispatcher(”/view.jsp”);
}
view.jsp
We have some data to display: <b>
${d.property1}
</b>
•
In this case, the data passed is a simple bean
-
style object.
It could also be an XML document; we’d then use JSTL’s
XML
-
manipulation tags.
Transferring data
Use XML documents (i.e., DOM
objects) and the JSTL
<x:*>
tags
Use JavaBean
-
style classes
public class MyData {
public String getCustomerName() { return X; }
public Date getCustomerBirthday() { return Y; }
}
${myDataInstance.customerName}
Summary. Or, what’s new?
This was all possible before. What
are the benefits of the newer
standards and technologies?
Easier development
Easier debugging
Easier maintenance
Easier reuse
URLs
Official JSTL site (spec, implementations)
http://java.sun.com/products/jstl
Quick JSTL reference
http://www.manning.com/bayern/appendixA.pdf
Official JSP site
http://java.sun.com/products/jsp
JSP 2.0 JSR (spec currently in Proposed Final Draft)
http://www.jcp.org/jsr/detail/152.jsr
JSTL in Action
http://www.jstlbook.com/
My email address
mailto:shawn.bayern@yale.edu
Enter the password to open this PDF file:
File name:
-
File size:
-
Title:
-
Author:
-
Subject:
-
Keywords:
-
Creation Date:
-
Modification Date:
-
Creator:
-
PDF Producer:
-
PDF Version:
-
Page Count:
-
Preparing document for printing…
0%
Comments 0
Log in to post a comment