Download JSP 2.0 and JSTL: Principles and patterns

JSP 2.0 and JSTL:
Principles and Patterns
Shawn Bayern
Research Programmer, Yale University
 JSTL reference-implementation lead
 Author, JSTL in Action
Web Development with JavaServer Pages

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
JSTL
Servlets
JSP
JSTL

Current standards:
JSP 1.2
 Servlet 2.3
 JSTL 1.0


In a few months:
JSP 2.0
 Servlet 2.4
 JSTL 1.1

Crash course on the J2EE
presentation tier

Servlets


JavaServer Pages (JSP)



Java classes that handle requests by
producing responses (e.g., HTTP requests
and responses)
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
web pages
Your application
JSTL
JavaServer Pages (JSP)
Java Servlet API
Java language
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
doStartTag()
doInitBody()
doCatch()
doEndTag()

release()
Tag handler
doAfterBody()
doFinally()
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 ( + )
29. concatenation
One-half of
self-employment
tax.
The addition operator either performs string
or numeric
addition.
The production AdditiveExpression : AdditiveExpression
+ MultiplicativeExpression
is evaluated as
Attach Schedule
SE.
follows:
30. Self-employed health insurance
1. Evaluate AdditiveExpression.
2. Call GetValue(Result(1)).
deduction (see page 33)
3. Evaluate MultiplicativeExpression.
31. Self-employed SEP, SIMPLE, and
4. Call GetValue(Result(3)).
5. Call ToPrimitive(Result(2)).
qualified plans
6. Call ToPrimitive(Result(4)).
32. Penalty
early
withdrawal
7. If Type(Result(5)) is String or Type(Result(6))
is String,on
go to
step 12.
(Note that this of
stepsavings
differs
from step 3 in the comparison algorithm
for the
relational paid
operators, by using or instead of and.)
33.
Alimony
8. Call ToNumber(Result(5)).
34. Add lines 23 through 33a
9. Call ToNumber(Result(6)).
10. Apply the addition operation to Result(8)
and Result(9).line
See the
below
(11.6.3).
35. Subtract
34note
from
line
22. This is
11. Return Result(10).
your adjusted gross income.
12. Call ToString(Result(5)).
13. Call ToString(Result(6)).
14. Concatenate Result(12) followed by Result(13).
15. Return Result(14).
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”)).getBeakColor()

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
 Comparisons
 Equality checks
 Logical operations
 Emptiness detection

${age + 3}
${age > 21}
${age = 55}
${young or beautiful}
${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
attributes
doStartTag()
doCatch()
Tag
body
doEndTag()

release()
Tag handler
doInitBody()
doAfterBody()
doFinally()
SimpleTag handler
Tag
attributes
Tag
body
doTag()

Tag handler
(no
scriptlets)
JSP 2.0:
Improved XML syntax
Old style: JSP as document
<jsp:root>
New style: JSP as namespace
xmlns:jsp=“http://java.sun.com/JSP/Page”

Other changes

<jsp:element>, <jsp:attribute>
• Avoids <a
href=”<c:url value=”…”/>”/>
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.
The parable of
Mike and Phillipe
Mike
Credit: Pierre Delisle (spec lead)
Phillipe
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)
Text formatting
c
XML manipulation
x
Database access
sql
fmt
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



<fmt:formatNumber type=“currency”
value=“${salary}” />
Internationalization


Numbers
Dates
Message bundles
<fmt:message key=“welcome” />
Message argument substitution

“Hi {0}. I would like to {1} your money today.
I will use it to buy myself a big {2}.”
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)
<sql:query sql=“SELECT * FROM USERS”
var=“result” />
<c:forEach items=“${result.rows}”> … </c:forEach>




Updates / inserts
Transactions (<sql:transaction>)
Parametric (PreparedStatement) argument
substitution (<sql:param>)
DataSource-based connection management
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:[email protected]
Q&A

Syntax? Semantics? Other features?

Java Community Process procedures,
anecdotes?

Future directions?