学步园

JSF 2.0 proposal has been posted on March 2007 and planned for the release in last quarter of 2008. It will be shipped with JEE 6.0 release. Looking into the
features lits of the JSF 2.0, it is added lots of interesting features in the list and also they are aiming to attract more new developers to use JSF technology.

JSF 2.0 Features

Some of the interesting features includes Bookmarking for URLs, expanding the existing lifecycle mechanism, more support
for the AJAX requests, use annotations instead of faces-config.xml, introducing JSFTemplating concepts and much more. It seems
the list size is big it will be great to see when the final version is released. Basically it is categorized into four parts:
Ease of development, New Features, Performance and Adoption. We will look into the each category with brief explanation. This tips based on the JSR 314 and the features list is taken from the original JSR document.

Ease of development

• Component aggregation. Allow development of custom component with
  little or no Java coding. [A] Perhaps consider a standard set of
  aggregations.
• Allow for "zero configuration" web applications. No
  faces-config.xml, no web.xml. If necessary, annotations will be used to
  supplement the configuration data.
• Vastly improve the developer experience with regard to error
  messages that happen during iterative development, and even during
  deployment of the application. For example the EG will consider options
  including, allowing the developer to tell the runtime what stage of
  development the web application is in, and take action accordingly:
  Development, Test, Deployment. Line precise error reporting. Pluggable
  Exception Handling.
• Provide default exception handling mechanisms. For example, all runtime errors get forwarded to an error page.
• Eliminate the need to author a JSP tag handler when writing JSF components.
• Leverage annotations to declare JSF artifacts (components, managed beans, navigation rules, etc) to the runtime.
• Declarative Renderers, otherwise known as Renderers without resorting to out.println().
• Real world, production view description technology, including
  templating: include something influenced by Facelets, JSFTemplating or
  Tiles in the specification.
• Make it very easy to create CRUD based applications.

New Features

• Expand the request processing lifecycle to be aware of Ajax. This
  may include describing a small developer-contract footprint JavaScript
  library as part of the JavaServer Faces specification.
• Separate the "build the tree" and "render the tree" processes into two separate lifecycle phases.
• Allow for partial tree traversel during lifecycle execution via Ajax.
• Allow for bookmarkable JSF pages. More broadly, if HTTP GET can be used, it should be used.
• Decent client side, inter-component and form-level validation (leveraging JSR-303 validation if possible).
• First class support for bundling and delivering static resources
  associated with a component: images, stylesheets, scripts, etc. Should
  be able to specify default locations for resources.
• Strategic additions to the Standard HTML RenderKit: Date Picker, Tree, Tab View, File Upload components.
• Provide a mechanism to minimize the "Lost Update" and "Duplicate
  Button Press" problems. These mechanisms must be pluggable or
  customizable from the user.
• Page actions: The ability to say, "when this page loads, invoke this action (via Ajax if necessary)."
• Provide a mechanism to easily access persistent store.

Performance

• Saving and restoring page deltas rather than saving and restoring the full view state each time.
• Re-do UIComponent state saving with a view towards making stateless components the default.
• Allow for moving as much of the event processing and inter-page
  component interaction into the client as possible. This may imply
  specifying client side controller framework.
• Streamline the rendering process via caching if possible.
• Improve the interceptor mechanism delivered via the PhaseListener
  feature so that the developer can control exactly what kinds of
  requests are allowed to be processed by each PhaseListener instance.

Adoption

• Enable components to have a client based lifecycle in addition to,
  or instead of the server based request/response lifecycle. Such a
  client based lifecycle would enable use-cases such as drag-and-drop,
  master-detail and sub-dialogs on a single page interface web
  application.
• Improve the UIComponent specification to allow an increase in the
  interoperability of UIComponent libraries from arbitrary vendors.
• Enable applications to use features that are defined in the
  JavaServer Faces specification but are intended for use in the Java EE
  platform as a whole. For example, the managed bean facility is useful
  even in an application that only uses Servlets from Java EE but
  provides the rest of the web application features from software outside
  of the platform.
• Allow JSF application resources to be accessed via REST.
• Enable components that publish events via RSS/Atom.
• Add support for REST (JSR 311)
• Broad and pervasive support for scripting at all levels of the
  specification. It will be possible to use a scripting language to write
  all executable artifacts in a JSF application.
• Specify command line interface for authoring JSF applications.
• Support for passing values from page to page. This will be a
  standardization of the many different Dialog/Conversation/Scope/Flash
  ideas currently in use.
• "Skinning", or "Themeing" of components.
• An important target user for JavaServer Faces technology is the
  developer who relies on an Internet Service Provider (ISPv) to host
  their application, as well as hosting their development environment. It
  must be easy to iteratively develop a JavaServer Faces application that
  is hosted entirely on an ISP.

转自：http://www.javabeat.net/tips/116-new-features-in-jsf-20.html