JSP 2.0 and JSTL: Principles and Patterns

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