JSP 2.0 and JSTL: Principles and Patterns

thickbugΛογισμικό & κατασκευή λογ/κού

28 Οκτ 2013 (πριν από 3 χρόνια και 10 μήνες)

65 εμφανίσεις

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