Newfeaturesincontext 130911052709-phpapp01

Copyright © 2013, Oracle and/or its affiliates. All rights reserved. I1
JSF 2.2 New Features
in Context
Edward Burns
@edburns
Consulting Member of Staff, Oracle

My plan for your time investment
 How is JSF still relevant?
 JSF 2.2 Big Ticket Features: in Context
– 1055 Stateless Views: Context: Performance
– 1090 HTML5 Friendly Markup: Context: Markup Evolution
– 730 Flows and 1142 Resource Library Contracts:
Context: Multi-tenancy and Modularity
 Other features: Context free

The following is intended to outline our general product direction. It is intended
for information purposes only, and may not be incorporated into any contract.
It is not a commitment to deliver any material, code, or functionality, and should
not be relied upon in making purchasing decisions. The development, release,
and timing of any features or functionality described for Oracle s products
remains at the sole discretion of Oracle.

 JSR 127
– JSF 1.0 11 March 2004
– JSF 1.1 27 May 2004
 JSR 252
– JSF 1.2 11 May 2006
– JSF 1.2 Maintenance Release 1
19 December 2006
13 June 2008
25 August 2008
Where is JSF in its Lifecycle?
JSR Timeline  JSR 314
– JSF 2.0 1 July 2009
– JSF 2.1 16 July 2010
22 November 2010
 JSR 344
– Started 14 April 2011
– Early Draft Review released
8 December 2011
– Proposed Final Draft 14 Mar 2013
– Final June 2013
http://bit.ly/JavaEE7WrapsUp

WE STILL NEED WEB APPS THAT ARE
QUICK TO
BUILD,MAINTAINABLE, LOCALIZABLE, AC
CESSIBLE,
SECURE, DEVICE INDEPENDENT, GOOD
LOOKING, AND ARE FUN TO USE
How Can JSF Still Be Relevant?
Abstractions Endure

Is JSF Really That Old?
JavaOne 2001
technical keynote

Restate the Scope of JSF
 Separate Component Semantics from Rendering
 Allow components to “own” their little patch of the UI
– encode/decode
 Well defined lifecycle: Inversion of Control
UI Logic Substantially on Server

 Unofficial usage tracked at
http://bit.ly/RealWorldJsfLinks2
 or google RealWorldJsfLinks
JSF Used on Every Continent
Real World JSF Links

What’s Hot Now?
 HTML5 native applications
– JavaScript MVC frameworks
– REST
 Dan North, thought leader
– “The Browser is Dead…”
 http://bit.ly/DanNorthBrowserIsDead PDF
 http://bit.ly/DanNorthBrowserIsDeadVideo YouTube

Dan North’s Assessment of What’s Hot Now
 Technologies
– Graphics: 2D and 3D + transforms
– Client local storage
– Sever Sent Events: Web Sockets
– Ecmascript
 Techniques
– Everything is asynchronous
– Don’t page template, just use the DOM (jQuery)
– No UI state on the server

Dan North’s Assessment of What’s Hot Now
 Use standards…
– W3C standards
– JCP standards?
 JSON JSR-353
 WebSocket JSR-356
 JAX-RS JSR-339

So why are these things hot now?
 Flashy results?
 Maintainability?
 Better runtime performance  potential for better user experience?
 Wider reach?

 Flashy results?
– This is a component library concern. Many component libraries have very
flashy components.
– Abstractions endure
 Wider reach?
JSF responses

 Flashy results?
– JavaEE/JSF was designed for large teams of corporate developers
producing code that needs to stick around long after said developers have
moved on.
– For example, emphasis on statically typed technologies
 Wider reach?
JSF responses

 Flashy results?
– With any technology, including the HTML5 native approach, it is possible to
produce a poorly performing user experience. The question is how hard is
it to produce a decently performing one.
– Stateless JSF is a step in that direction.
 Wider reach?
JSF responses

 Flashy results?
 Wider reach?
– JSF was designed for client device independence
– HTML5, while growing, is still not at the least common denominator level
– Being able to support IE 6 is sometimes still important
JSF responses

 Flashy results?
 Wider reach?
JSF responses

In reality, many approaches can co-exist
 JSF for one class of developers/users
 HTML5 native for another
 Re-use in the application tier

Where is JSF in its Lifecycle?
Implementation Status
 Oracle Mojarra JSF 2.2.0 is in GlassFish 4.0, which requires JDK7
 It will also run on GlassFish 3.1+, which requires JDK6
 It will also run on Tomcat 7 (but you must bring your own CDI if you
want to use CDI dependent features such as Faces Flows)

 Big Ticket Features: in Context

JSF 2.2 Big Ticket Features
in Context
Issue numbers relative to JSF JIRA
http://jsf-spec.java.net/issues/

New to JSF?
 JSF 2.0 was a blockbuster release
– Facelets
– Composite Components
– Ajax
– Resource Libraries
2.0 Big Ticket Feature Review

1055 Stateless JSF
 Kinds of state in a JSF app
– UIComponent state
– Model tier state
– Persistence tier state
What is state?

1055 Stateless JSF
What is state?

1055 Stateless JSF
 Context: Stateless is important mostly as performance concern
– See http://bit.ly/LeonardoJsfPerformance Leonardo Uribe’s paper
– Much can be done in the way you use JSF to reduce statefulness
What is state?

1055 Stateless JSF
 Leverage existing API
 Biggest gain for smallest change
– Expose existing UIComponent transient property on f:view
<f:view transient=“true”>
– Spec changes in Restore View Phase, ResponseStateManager
 Be advised
– Must be on outer-most <f:view> in Facelets inclusion
– View scoped managed beans will not work if the view is marked stateless
JSF 2.2 approach to stateless

1055 Stateless JSF
 Automatic state management is a key value-add of JSF
– Differentiates it from RESTful
 Pros
– Can be lazy with your UI,
Why is this important?

1090 HTML5 Friendly Markup
 This is a JSF page
The best part of Wicket comes to JSF

 JSF Views are written in a View Declaration Language (VDL).
 The standard Facelet VDL is an XML application with two kinds of
elements
– HTML Markup
– JSF Components
 HTML Markup is passed through straight to the browser
 JSF Components take some action on the server, during the lifecycle
Let’s get back to basics

 Before JSF 2.2
– JSF tags hide complexity of underlying HTML+script+css+images
– JSF “Renderer”:
 encode: markup to browser
 decode: name=value from browser
<html>…
<my:colorPicker value=“#{colorBean.color2}” />
<my:calendar value=“#{calendarBean.date1}” />
</html>
 Context: Missing feature in browser? Write a JSF component.
Let the elegance of HTML shine through

 With JSF 2.2
– Pure HTML+script+css+images in the JSF page
– JSF Renderer handles decode from browser
 Leverage the strength of the JSF lifecycle
 Leverage the expressiveness of HTML5
<html>…
<input type=“color” jsf:value=“#{colorBean.color2}”/>
<input type=“date” jsf:value=“#{calendarBean.date1}” />
</html>
 Context: New feature in browser? Use “pass through elements”

 DEMO

1142 Resource Library Contracts
730 Faces Flows
 Allow composing a JSF app as a
collection of modules
– Faces Flows modularize behavior
– Resource Library Contracts modularize
appearance
 Well defined contract for each
Modularity and Multi-tenant capability

1142 Resource Library Contracts 730 Faces Flows
 Two new concepts in JSF 2.2
– Resource Library Contract
– Faces Flows
What’s going on here?
Builds on facelets concepts
Builds on navigation concepts

Resource Library Contracts
Facelets Review
<ui:define name="headline">
Today's News
</ui:define>
<ui:define name="story">
Facelets is now a part
of JSF 2.0...
</ui:define>
T eFaceletsGazet e
Sit
Navigat on
● Events
● Docs
● Forums
About Contact Sit M ap
_template.html
template client
greeting.html

Facelets Review T eFaceletsGazet e
Sit
Navigat on
● Events
● Docs
● Forums
About Contact Sit M ap
Template File name
_template.html
Insertion points
Resources
css classes, scripts, images

A Contract is Born
• Declared Templates
• Declared Insertion Points
• Declared Resources
contractA

Loading Conventions
contractA
contractB
contractC
<web-app-root>/contracts

Loading Conventions
contractA
contractB
contractC
contractD
contractE
contractF
JAR ﬁles in WEB-INF/lib

Loading Conventions
contractA
contractB
contractC
contractD
contractE
contractF
Set of available contracts

Loading Conventions
contractA
contractB
contractC
contractD
contractE
contractF
Facelet 1 Facelet 3Facelet 2

Loading Configuration
contractA
contractB
contractC
contractD
contractE
contractF
Facelet 1 Facelet 3Facelet 2
faces-conﬁg.xml

Loading Configuration
contractA
contractB
contractC
contractD
contractE
contractF
Facelet 1
<f:view contracts="contractA">
...
Facelet 3Facelet 2
faces-conﬁg.xml

 Resource Library Contract
– Convention
 Available contracts discovered at startup
 All of them are made available to the application
 Assumes there are no naming collisions
– Configuration
 faces-config.xml <resource-library-contracts> element
– Controls which parts of the app are allowed to use which contracts
 contracts attribute in <f:view>
– Declares that this view is only able to use these named contracts
Modular Appearance

Faces Flows
Standards are for Standardizing, Not Innovating
 ADF Task Flows
 Spring Web Flow
 Apache MyFaces CODI
Architectural Pedigree

Flow Concepts
 Can be “called” from any place in the application
 Single entry point
 Input parameters and return values
 Well defined interface contract
– Internal implementation details hidden
 New flowScoped for flow local storage
 New @FlowScoped CDI annotation: automatic activation/passivation
Hint: Think of a flow like a Java method

Flow Navigation
 Navigation is no longer just between pages
 Navigation is now between flow “nodes”
 Information Hiding comes to JSF. Welcome to 1972!
 Multiple node types:
– View
– Method Call
– Switch
– Flow Call
– Flow Return

Flow Navigation
 Flow represented at
runtime by instance of
javax.faces.flow.Flow
 JSF 2.2 authoring
experience
– XML
– Builder

730 Faces Flows 1142 Resource Library Contracts
– Faces Flows
 Each builds on the packaging scheme in JSF 2.0
– A special directory in the web app root
 /contracts
 /flows
– A special location in the Classpath
 /META-INF /contracts
 /META-INF/flows

730 Faces Flows 1142 Resource Library Contracts
– Faces Flows
 Each builds on the packaging scheme in JSF 2.0
– A special directory in the web app root
 /contracts
 /flows
– A special location in the Classpath
 /META-INF /contracts
 /META-INF/flows
Useful during development
Useful during deployment
}
}

1142 Resource Library Contracts
 DEMO
Explore the contracts aspect of flow_and_contract and scrumtoys demo

730 Faces Flows
Standards are for Standardizing, Not Innovating
 ADF Task Flows
 Spring Web Flow
 Apache MyFaces CODI
Architectural Pedigree

730 Faces Flows
 Can be “called” from any place in the application
 Single entry point
 Input parameters and return values
 Well defined interface contract
– Internal implementation details hidden
 New facesFlowScope for flow local storage
 New @FlowScoped CDI annotation: automatic activation/passivation
Hint: Think of a flow like a Java method

 Navigation is no longer just between pages
 Navigation is now between flow “nodes”
 Information Hiding comes to JSF. Welcome to 1972!
 Multiple node types:
– View
– Method Call
– Switch
– Flow Call
– Flow Return
730 Faces Flows
Navigation

 Flow represented at
runtime by instance of
javax.faces.flow.Flow
 JSF 2.2 authoring
experience
– XML
– Builder
730 Faces Flows
Navigation

Flow Definition
 Name of the flow
 Where does the flow start?
 Input values
 Optional initializer & finalizer

Flow Definition

730 Faces Flows
Spec challenge
 Ensuring the feature works well with the existing JSF features
– POSTback based navigation: <h:command{Button,Link}>
– GET based navigation: <h:{button,link}>
 Navigation rules
– Was one level
– Now is a stack
– “return” case was tricky

 Big Ticket Features: in Context

Other Features
• Medium Sized
• Small Sized

Medium Sized Features
1. 1042 ViewActions
2. 869 CSRF protection
3. 949 ClientWindow
4. 802 File Upload
5. 763 CDI injection of JSF artifacts
6. 599 Programmatic Composite Component creation
7. 594, 703 FacesComponent enhancetments
8. 479 UIData implements Collection
9. 1001 Composite and Java components in the same library
10. 533 Programmatic faces-config

1042 ViewActions
 JSF 2.0 introduced <f:metadata>
– Use with <f:viewParam>
 JSF 2.2 introduces <f:viewAction>
– Use inside of <f:metadata>
– Use along side of <f:viewParam>
 Like a button that clicks itself
– Can cause navigation
– Can choose the lifecycle phase
 UIViewAction component sits behind <f:viewAction> tag.

869 Cross Site Request Forgery Protection
 What is Cross Site Request Forgery
(CSRF, pronounced SEE-surf)?
– http://en.wikipedia.org/wiki/Cross-site_request_forgery
– Trick the browser into sending requests that the user did not actually intend
to initiate
JSF Is Not Just for POSTback Anymore

869 Cross Site Request Forgery Protection
 How does JSF protect your app against this attack?
1. It already does and always has!
POSTback is a virture. JSF 2.2 just makes encryption of the view state on
by default
2. New <protected-views> section in faces-config
 View Token
– When rendering a non-POSTback link or button
 Referer [sic] and Origin headers
JSF Is Not Just for POSTback Anymore

949 ClientWindow
 JSF finally has framework level support for the many different ways a
UIComponent tree can be rooted
– Browser tab
– Browser window
– Browser pop-up
– Portlet
– …
 New class javax.faces.lifecycle.ClientWindow
– A client window is always associated with exactly one UIViewRoot instance
at a time, but may display many different UIViewRoots during its lifetime.

949 ClientWindow
 FacesServlet now must call Lifecycle.attachWindow()
 Lifecycle.attachWindow()
– Takes no action unless feature is enabled
– Looks for incoming client window
– Creates one if not present
– Stores it on the ExternalContext
How does it work?

802 File Upload Component
 For the benefit of Apache Tomcat users, JSF has always chosen to lag
one Servlet version behind the Java EE umbrella spec in which it is
included
Why so long?
Included
JSF
Version
Included
Servlet
Version
Minimum Servlet
Version for
Included JSF
J2EE 1.4 1.1 2.4 2.3
Java EE 5 1.2 2.5 2.4
Java EE 6 2.0 3.0 2.5
Java EE 7 2.2 3.1 3.0

 Final spec has “Ajax” and non-Ajax support
 “Ajax” can be XHR level 2 or hidden IFRAME
<h:inputFile id="file"
value="#{fileUploadBean.uploadedFile}">
<f:validator validatorId="FileValidator" />
</h:inputFile>
Usage

@ManagedBean
@RequestScoped
public class FileUploadBean {
private Part uploadedFile; // getter/setter
public String getFileText() {
String text = "";
if (null != uploadedFile) { try {
InputStream is = uploadedFile.getInputStream();
text = new Scanner( is ).useDelimiter("A").next();
} catch (IOException ex) {}
}
return text;
}
}
Usage

@FacesValidator(value="FileValidator")
public class FileValidator implements Validator {
@Override public void validate(FacesContext context,
UIComponent component, Object value) throws ValidatorException {
Part file = (Part) value;
try {
InputStream is = file.getInputStream();
text = new Scanner( is ).useDelimiter("A").next();
} catch (Exception ex) { throw new ValidatorException(“”, ex); }
if (!text.contains("JSR-344")) {
throw new ValidatorException(new FacesMessage("Invalid file”);
}
}
Usage

763 CDI Injection of JSF Artifacts
 All Common Annotation and CDI Annotations must work in
– ELResolvers
– Factories
– JSF singletons (ResourceHandler, StateManager, etc)
– ActionListeners

599 Programmatic Component Creation
 Application.createComponent()
– Used to create UIComponent instances given component-family, etc
 ViewDeclarationLanguage.createComponent()
– Used to create UIComponent instances given tag library URI, tag name,
and optional attributes
– Equivalent to using the tag in a page
– Designed for use with composite components

594, 703 FacesComponent enhancements
 @FacesComponent added in JSF 2.0
– Allows declaring a UIComponent to the runtime
 JSF 2.2 adds new attributes (with sensible defaults)
– createTag causes a facelet tag handler to automatically be created
– namespace declares the tag library namespace in which the tag handler
will reside
– tagName declares the tag name
– value now has a default behavior

479 UIData supports Collection
 Prior to JSF 2.2, UIData only supported
– Arrays
– java.util.List
– java.sql.ResultSet
– javax.servlet.jsp.jstl.sql.Result
 JSF 2.2 adds
– java.util.Collection

1001 Composite and Regular Components
 Prior to JSF 2.2, was not possible to have both kinds of components in
the same tag library
 Now it is.
Both in the same tag library

533 Programmatic faces-config
 New class
javax.faces.application.ApplicationConfigurationPopulator
 Is a java.util.ServiceLoader service
 Has a populateApplicationConfiguration() method
– Gets passed an “empty” DOM Document
– You can populate it as if it were a regular faces-config.xml file.
– It gets put in with the rest of the discovered faces-config files.

Other Features
• Medium Sized
• Small Sized

Small Sized Features
 1142 “reset button” API
 766 Events from the Flash
 1134 “role” passthrough attribute
 1050 Ajax delay
 1085 httpOnly cookie support

Q&A

The preceding was intended to outline our general product direction. It was
intended for information purposes only, and may not be incorporated into any
contract. It is not a commitment to deliver any material, code, or functionality, and
should not be relied upon in making purchasing decisions. The development,
release, and timing of any features or functionality described for Oracle s
products remains at the sole discretion of Oracle.

Newfeaturesincontext 130911052709-phpapp01

More Related Content

What's hot (20)

Similar to Newfeaturesincontext 130911052709-phpapp01 (20)

Recently uploaded (20)

Newfeaturesincontext 130911052709-phpapp01