JSP 2.0 and JSTL: Principles and Patterns

1
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

2
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?

3
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

4
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.

5
Organization of the platform
Your application
Your web pages
JSTL
JavaServer Pages (JSP)
Java Servlet API
Java language
6
What kinds of things go in JSP pages?

• Scriptlets
• getFoo(request)
• printFoo(out)
• String a goat
• Oink!

• Java (and more?) embedded within template text
• Access to implicit objects request, response,
  etc.
• Conditional blocks, loopsmanually constructed

7
What kinds of things go in JSP pages?

• Tag libraries
• c is true
• Round and round we go

• XML tags
• Invoke Java logic behind the scenes.
• May access body, e.g., for iteration, conditional
  inclusionor just as arbitrary parameter
• May access PageContext
• Libraries and prefixes

8
Question 1

• Why JSP 2.0?
• (Or, whats wrong with the current version of
  JSP?)

9
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)

10
Whats irritating about JSP?
(?)

• The tag-extension protocol is too complicated

Tag handler
doStartTag()
doEndTag()
?
Too hard for Gosling, even?
doInitBody()
doAfterBody()
doCatch()
doFinally()
release()
11
Whats irritating about JSP?
(?)

• Also, tags dont support certain kinds of code
  reuse.

?
out.println() for() out.println()
12
Whats bad about JSP? (?)

• The general consensus says
• Scriplets
• They complicate abstraction and code reuse.
• They make it harder for nonprogrammers to
  maintain pages

13
Question 2

• What new features does JSP 2.0 offer?
• (Or, how does it fix the issues we just raised?)

14
How does JSP 2.0 address these issues?

• Expression language
• Tag files
• Simplified Tag API (SimpleTag versus Tag)
• Improved XML syntax
• Also, though its not really part of JSP,
• JSTL improves things too.
• The end result
• JSP pages become easier to write and maintain.

15
The JSP Expression Language (EL) Goals and
principles

• The major goal simplicity.
• The language should be usable by nonprogrammers.
• Inspirations JavaScript, XPath
• But its much simpler than even these basic
  expression languages.
• Quick what does //foo bar mean in XPath?
• Or what happens with age 3 in ECMAScript?

16
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.

17
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)).

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.
18
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)

19
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)).getBea
  kColor()
• 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.)

20
The JSP Expression Language (EL) advanced data
access

• Expressions may also refer to cookies, request
  parameters, and other data
• cookie.crumb
• param.password
• headerUser-Agent
• pageContext.request.remoteUser

21
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

22
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
• Hi, user.
• You are
  years old.

23
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 directive
  instead of traditional
  directive.

24
JSP 2.0 tag files

• Name
• IQ
• i.fullName
• i.IQ

25
Using the new tag

• Your shopping cart
• Your wish list
• Things we want you to buy

26
Old tag handler
Tag handler
doStartTag()
doEndTag()
Tag body
Tag attributes
?
doInitBody()
doAfterBody()
doCatch()
doFinally()
release()
27
SimpleTag handler
Tag handler
doTag()
Tag body (no scriptlets)
Tag attributes
?
28
JSP 2.0 Improved XML syntax

• Old style JSP as document
• New style JSP as namespace
• Other changes
• ,
• Avoids /

xmlnsjsphttp//java.sun.com/JSP/Page
29
Question 3

• What is JSTL? What features does it offer?

30
JSTL design principles

• JSTL 1.0 Keep it simple!
• Targeted tags
• Could have a single tag
• 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.

31
The parable of Mike and Phillipe
Mike
Phillipe
Credit Pierre Delisle (spec lead)
32
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

33
JSTL 1.0 libraries

34
JSTL featuresmanaging variables

• Outputting values with EL
• Storing data
• scopesession
• // arbitrary text
• Note the use of var and scope a JSTL
  convention

35
JSTL featuresiteration

• Iteration
• begin5 end20 step4
• varitem
• paging

36
JSTL featuresconditional logic

• Conditional evaluation
• a equals b

• Mutually exclusive conditionals
• a equals b
• a equals c
• I dont know what a equals.

37
JSTL featuresURL management

• Retrieving data
• urlhttp//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
• Redirection

38
JSTL featurestext 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.

valuesalary /

39
JSTL featuresXML manipulation

• Use of XPath to access, display pieces of XML
  documents
• varcnn/
• Chaining XSLT transformations

40
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

41
JSTL featuresdatabase manipulation

• Queries (and ResultSet caching)
• Updates / inserts
• Transactions ()
• Parametric (PreparedStatement) argument
  substitution ()
• DataSource-based connection management

varresult /

42
SQL tags the debate
JSP page
Back-end Java code
Tag library
Database
Tag library
JSTL SQL tags
43
SQL TagsThe expert groups conclusion

• SQL tags are needed because
• many nonstandard offerings exist
• it is not JSTLs role to dictate a choice of
  framework
• As popular as MVC is, its 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.

44
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.

45
JSTL programmer support

• JSTL API allows registrations of defaults
• DataSource
• Limit on size of results
• Localization context (Locale, etc.)
• Time zone

46
Question 4

• How do the technologies work together?

47
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.

48
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.

49
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 d.property1b

• In this case, the data passed is a simple
  bean-style object. It could also be an XML
  document wed then use JSTLs XML-manipulation
  tags.

50
Transferring data

• Use XML documents (i.e., DOM objects) and the
  JSTL tags
• Use JavaBean-style classes
• public class MyData
• public String getCustomerName() return X
  
• public Date getCustomerBirthday() return
  Y
• myDataInstance.customerName

51
Summary. Or, whats new?

• This was all possible before. What are the
  benefits of the newer standards and technologies?
• Easier development
• Easier debugging
• Easier maintenance
• Easier reuse

52
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
• mailtoshawn.bayern_at_yale.edu

53
QA

• Syntax? Semantics? Other features?
• Java Community Process procedures, anecdotes?
• Future directions?