Introduction to

JavaServer Faces v2.0

26 Dec 2010
Topics
 Different views of JSF
 Pros & Cons of JSF
 Vs. standard servlet and JSP technology
 Vs. Apache Struts
 Vs. other AJAX approaches
 New features in JSF2.0
 Vs. JSF 1.x

2
What is JSF?
 A set of Web-based GUI controls and handlers?
 JSF provides many prebuilt HTML-oriented GUI
controls, along with code to handle their events.
 A device-independent GUI control framework?
 JSF can be used to generate graphics in formats
other than HTML, using protocols other than HTTP.
 An MVC-based Web app framework?
 Like Apache Struts, JSF can be viewed as an MVC
framework for building HTML forms, validating their
values, invoking business logic, and displaying
results.

3
Continues…
 An Ajax library?
 JSF 2.0 provides very easy-to-use Ajax
support. So, JSF 2.0 can be viewed as an
alternative to jQuery or GWT.
 Butwhich is the proper way to
view JSF?
 The answer depends on what you are going to use it
for, but 1 & 3 are the most common wasy of looking at
JSF.

4
JSF Vs. Servlets/JSF
JSF Vs. Servlets/JSF

5
JSP Compilation and Execution
JSP Page
First request
after creation or
Automatic Compilation
modification
JSP Servlet

Subsequent init()
Requests (can
be from
different users service()
and sessions)
Compile JSP Servlet Instance in Memory

6
Advantages of JSF (vs. MVC Using
RequestDispatcher)
 Custom GUI controls
 JSF provides a set of APIs and associated
custom tags to create HTML forms that have
complex interfaces
 There are many extra-rich third-party JSF libraries
 Event handling
 JSF makes it easy to designate Java code that is
invoked when forms are submitted. The code can
respond to particular buttons, changes in particular
values, certain user selections, and so on.

7
Continued…
 Managed beans
 In JSP, you can use property="*" with jsp:setProperty
to automatically populate a bean based on request
parameters. JSF extends this capability and adds in
several utilities, all of which serve to greatly simplify
request param processing.
 Integrated Ajax support
 You can use jQuery, Dojo, or Ext-JS with servlets and
JSP. However, JSF lets you use Ajax without explicit
JavaScript programming and with very simple tags.
Also, the Ajax calls know about the server-side
business logic.

8
Continued…
 Form field conversion and validation
 JSF has builtin capabilities for checking that form values are in the
required format and for converting from strings to various other data
types. If values are missing or in an improper format, the form can be
automatically redisplayed with error messages and with the previously
entered values maintained.
 Centralized file-based configuration
 Rather then hard-coding information into Java programs, many JSF
values are represented in XML or property files. This loose coupling
means that many changes can be made without modifying or
recompiling Java code, and that wholesale changes can be made by
editing a single file. This approach also lets Java and Web developers
focus on their specific tasks without needing to know about the overall
system layout.
 Consistent approach
 JSF encourages consistent use of MVC throughout your application.

9
Disadvantages of JSF (vs. MVC
with RequestDispatcher)
 Bigger learning curve
 To use MVC with the standard RequestDispatcher, you need to
be comfortable with the standard JSP and servlet APIs. To use
MVC with JSF, you have to be comfortable with the servlet API
and a large and elaborate framework that is almost equal in size
to the core system..
 Similarly, if you have an existing app and want to add in some
small amounts of Ajax functionality, it is moderately easy with
jQuery (quite easy if you know JavaScript already). Switching
your app to JSF 2.0 is a big investment.
 Worse documentation
 Compared to the standard servlet and JSP APIs, JSF has fewer
online resources, and many first-time users find the online JSF
documentation confusing and poorly organized. True for both
Mojarra and MyFaces..

10
Disadvantages of JSF (vs. MVC
with RequestDispatcher)
 Less transparent
 With JSF applications, there is a lot more going on
behind the scenes than with normal Java-based Web
applications. As a result, JSF applications are:
 Harder to understand
 Harder to benchmark and optimize
 Undeveloped tool support
 There are many IDEs with strong support for standard servlet and JSP
technology. JSF 2.0 is pretty new, and IDE support is weak as of
7/2010.
 Rigid approach
 The flip side of the benefit that JSF encourages a consistent approach
to MVC is that JSF makes it difficult to use other approaches.

11
Struts is a Serious Alternative
 Struts is the most popular alternative to
JSF
 But there are many more
 SpringMVC.
 Apache Wicket.
 Apache Tapestry
 jMaki

12
Advantages of JSF(vs. Struts)
 Custom components
 JSF makes it relatively easy to combine complex GUIs into a
single manageable component; Struts does not
 There are many existing third-party component libraries for
JSF,virtually none for Struts
 JBoss RichFaces, Oracle ADF, IceFaces, Apache Tomahawk,
Woodstock, Web Galileo, Pretty Faces, …
 Support for other display technologies
 JSF is not limited to HTML and HTTP; Struts is.
 Access to beans by name
 JSF lets you assign names to beans, then you refer to them by
name in the forms. Struts has a complex process with several
levels of indirection.

13
Advantages of JSF(vs. Struts)
 Official part of Java EE
 JSF is part of the Java EE spec, and all servers that support
Java EE include JSF (JSF 2.0 is part of Java EE 6)
 Expression language
 The JSF expression language is more concise and powerful
than the Struts bean:write tag.
 This is less advantageous vs. Struts 2.0
 Simpler controller and bean definitions
 JSF does not require your controller and bean classes to extend
any particular parent class (e.g., Action) or use any particular
method (e.g., execute). Struts does.

14
Advantages of JSF (vs. MVC Using
RequestDispatcher)
Servlet JSP

Development java classes (.java) scripting file (.jsp)

Deployment Manually compiled; Directly mapped: copy JSP

Specifically mapped files to intended directories

Execution No need of source Automatic compilation;

files automatic reloaded; source
files (.jsp) are necessary

15
JSP Elements
 Scripting elements
 Scriptlet
 Regular Java code
 Expression
 Shortcut for output
 Declaration
 Declaring variables and methods at the class level

 Directive

 JSP action

 Comments (<%-- … --%>)

16
Scriptlets
 Wraps regular Java statements which are usually written
within a method

<%
… (Java statements)
// may include comments, variable declaration and assignment, loops,
conditional statements, object initialization, method call, etc…
%>

 Using the implicit object “out” as the standard output

out.println( … ) or out.print( … )

See example “scriptlet-example.jsp” 17

Expression
 A shortcut to print out a value or an
expression

<%= [expression]%>

 Expression can be a variable, formula, object

property, string concatenation, method with
return value, or anything that returns a value

See example “expression-example.jsp” 18

JSP Output Practices
 Ways to treat static HTML content

 Regular/block output (servlet way)

 Uses “out.println()” or “out.print()” method to
generate all content, including static content

 “Spaghetti”/mixed output (scripting way)

 Uses JSP scriptlets or expressions for dynamic
content only
 Mixes scripting elements and static content

19
Regular Output
 Using “out.print()” or “out.println()” method
to generate HTML as a block, even the
whole page – Servlet way

 StringBuffer is often used to construct

HTML content first, and then printed out at
one time

See example “block-output.jsp” 20

Spaghetti Output
 Expression elements are often used where
dynamic content is needed

 Use regular HTML for static content; don’t

include them in JSP scripting elements

 How mixed should it be?

 Depends on your own style
 Coding should be most convenient and clear
 Depends on development requirement

See example “mixed-output.jsp” 21

Declarations
 Declaration element is used to define member variables
and methods

<%! … %>

 Variables not defined in declaration element are local / method

level variables
 Methods can only be defined in the declaration element

 Like regular class variables and methods, the location

where you define these variables and methods is not
important

See example “declaration.jsp” 22

JSP Page Directive
 Directives affects the overall structure of the
servlet generated

<%@ … %>

 Use page directive to import classes

<%@ page import=“…, …, …”%>

 Thisis equivalent to the “import” statement in regular

Java classes

23
JSP Include Directive
 How to reuse code?

 Use include directive to include source code

from another file

<%@ include file=“…” %>

 Inclusion happens at the compilation time

 What is included is the source, not generated result
 Often used to include method definitions

24
JSP Include Action
 Use “jsp:include” action to dynamically include content
from other files
 The statement is placed where the actual content will be inserted

<jsp:include page=“…” />

 “page” points to a local text file (.html, .htm, .jsp, .txt)

 Relative path
<jsp:include page=“menu.jsp” />

 Absolute path
 Note: absolute path starts from the current application context
<jsp:include page=“/menu.jsp” />

25
Include Action Usage
 “jsp:include” is often used to include the contents that
are consistent on many pages, e.g., menus, titles, page
headers, footnotes, …
 http://www.delta.com
 See example “ssi.jsp” and “WEB-INF/menu.jsp”

 Or, it is often used to include contents that are different

(dynamic inclusion)
 http://www.cardmemberservices.com/
 http://jackzheng.net/cis3270summer2006/
 See example “home.jsp” and “WEB-INF/course.htm”

 Or a hybrid model (templating)

26
Include Action and Directive Comparison

Include Action Include Directive

When does At request/run time At compilation time
inclusion occur?

What’s included? Final output of the Source code/content

included page

Main page Updates of the included Updates of the included

maintenance page is automatically page is NOT automatically
reflected reflected

 See table 13.1 one page 380 for a complete comparison of include
directive and include action

27
Redirection, Refreshing and Forwarding
 Redirection
 response.sendRedirect()

 Refreshing
 response.setHeader(“Refresh”, “10; url=…”)

 Forwarding <jsp:forward page=“…” />

 The “page” attribute follows the same rule as that of <jsp:include/>
 Forwarding does not invoke network traffic
 The destination URL is hidden; original requested URL does not change
in browser address bar after forwarding

 Compare redirecting and forwarding

See example “forward.jsp” 28

Request Processing
 Using implicit object “request”

 Processing HTTP request headers

 The same way as servlet

 Reading URL parameter

http://localhost/appcontext/request.jsp?choice=yes

 Parameter processing is the same way as servlet, using

request.getParameter(“…”), request.getPameterValues(“…”)

See example “request.jsp” 29

Form Processing with JSP
 The same way as servlet

request.getParameter(“…”)
request.getParameterValues(“…”)

 Note: the action attribute of the form should be a JSP

file that processes data

<form method=“post” action=“studentprofile.jsp”>…</form>

See example “studentprofile.htm” and “studentprofile.jsp” 30

Database Processing with JSP
 The same way as servlet
 Don’t forget the directive
<%@ page import="java.sql.*" %>

 See the example “product.jsp”

31
JSP Implicit Objects Summary
 Some system objects are initialize automatically
ready to use in the JSP environment
 out:standard output object
 request: represents request information and behavior
 response: represents response information and
behavior
 [session]: represents a typical time period of
communication between a client and a server
 [application]: represents context of a web application

32
Debugging JSP (Demo)
 JSP pages are automatically compiled

 Where to look for debugging information

 “500 Internal Server Error”: run time error information will be
display in the browser (default setting)
 Syntax error: caught by debugger within the IDE (not in browser)

 “500 Internal Server Error: ClassNotFoundException”

 JSP page is not compiled properly (may have syntax errors)

 “I don’t see any changes after a page is updated”

 The updated page may contain syntax error: check server
message
 Auto compilation failure: recompile the page manually
33
Resources
 JSP Reference
 http://java.sun.com/products/jsp/docs.html

 JSP Tutorial
 http://www.jsptut.com/

 JSP Best Practices

 http://www.javaworld.com/javaworld/jw-11-2001/jw-1130-jsp.html
 http://www.javaworld.com/javaworld/jw-07-2003/jw-0725-morejsp.html

34