JavaOne 2015 CON5211 Digital Java EE 7 with JSF Conversations, Flows, and CDI Scopes

Digital Java EE 7 with JSF
Conversations, Flows, and
CDI Scopes
Peter Pilgrim
JavaOne - CON5211
29th October 2015

Digital Java EE 7
JavaOne 2015 - CON5211 - P.E.A.T UK LTD (C) follow me on Twitter @peter_pilgrim 2

About me
▪ Java Champion
▪ Java programming since 1998
▪ Independent contractor, LTD UK
▪ Java EE developer, designer and book author

Agenda
▪ Java EE 7 modern architecture
▪ CDI Scopes
▪ Conversation scoped beans
▪ Faces-Flows and flow scoped beans
▪ Bootstrap your enterprise

"Nobody is madder than me
about the fact that the
website isn't working”
President Obama
Rose Garden Speech, 21th October 2013

Demonstration
Digital Java EE application

Digital Java EE 7 Platform
▪ Java EE 7 is standard architecture for
building enterprise Java solutions
▪ Transactions, persistence, management
▪ Dynamic content: Servlets, JSP, JSF and
MVC
▪ Remote endpoints EJB, JAX-RS, JMS
WebSocket and JCA

EJB Container
Poolable managed remote end points with transactions and
concurrency , which are application wide

EJB Beans
@Stateless
class ProductQueryService { ... }
@Stateful
class ShoppingCartDao { ... }
@MessageDriven
class OrderProcessor implements
MessageListener { ... }

CDI Container
Dependency Injection with lifecycle and contextual information
managing POJO instances in an enterprise web application

CDI Beans
@Named @RequestScoped
class LivePriceController { ... }
@Named @SessionScoped
class ShoppingCart implements Serializable {
... }
@ApplicationScoped
class Utility implements Serializable { ... }

Servlet Container
A specific container to manage Java Servlets, Filters and Context
Listeners for a web application HTTP

Web Infrastructure Beans
@WebServlet(“/prices/live”)
class LivePriceServlet extends HttpServlet {
... }
@WebFilter(“/prices”)
class PriceEnricher implements Filter { ... }
@WebListener
class UserSecurityRemover implements
HttpSessionListener,
HttpSessionAttributeListener { ... }

Request Scope
Session Scope
Application
Scope
Arrow ofTime

Context & Dependency
Injection 1.1
▪ Different lifespans for stateful objects
▪ Typesafe dependency injection
▪ Can decorate injected objects
▪ Can interpret methods
▪ Event notification model
▪ Portable extensions mechanism through SPI

Injection from CDI container
interface PaymentIssuer {
void allocate( int id );
}
@ApplicationScoped
public class CreditCardTicketTrackerImpl {
@Inject PaymentIssuer issuer;
/* ... */
}

CDI Qualifiers
import java.inject.Qualifier;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.FIELD;
@Qualifier
@Retention(RUNTIME)
@Target({FIELD}
public @interface Premier { }

Use CDI Qualifiers #1
@Premier
class StellarPaymentImpl implements PaymentIssuer {
void allocate( int id ) { ... }
}
@Standard
class BasicPaymentImpl implements PaymentIssuer {
void allocate( int id ) { ... }
}

Use CDI Qualifiers #2
@ApplicationScoped
public class SmartCreditCardTicketTracker() {
@Premium @Inject PaymentIssuer issuer1;
@Standard @Inject PaymentIssuer issuer2;
public void processTickets() {
if (nightTime) { ... } else { ... }
}
}

Injection from EJB container
@Stateless public class OrderDAO {
List<Order> findByCustomer( int custId ) {...}
}
@SessionScoped
public class CustomerOrderProcessor {
@EJB OrderDao orderDao;
/* ... */
}

Injection from Servlet
container
class LivePriceServlet
extends HttpServlet { ... }
class EntryController {
@Inject LivePriceServlet servlet;
// This does not work!
}

CDI: Inject a long lifespan
bean to a short lifespan bean
@ApplicationScoped class Utility { ...
}
class DeliveryController {
@Inject Utility utility;
/* ... */
}

CDI: Inject a long lifespan
bean to a short lifespan bean
@ApplicationScoped class Utility
implements Serializable { ... }
class ShoppingCartController implements
Serializable {
/* ... */
}

CDI: Inject a short lifespan
bean to a long lifespan bean
@RequestScoped class SecureDomain {
... }
class ShoppingCartController ... {
@Inject SecureDomain secDomain;
public void doAction() { ... }
}

CDI: Inject a short lifespan
bean to a long lifespan bean
@RequestScoped class SecureDomain { ... }
class ShoppingCartController ... {
@Inject SecureDomain secDomain;
public void doAction() {
secDomain.invoke(...);
/* YMMV - it might work because of proxies */
}
}

CDI Events – Define a domain
value object
public class LivePriceEvent {
private String product;
private double price;
public LivePriceEvent(String product, double price)
{ ... }
public String getProduct() { ... }
public double getPrice() { ... }
}

CDI Event Source
@ApplicationScoped
public class PriceUpdater {
@Inject Event<LivePriceEvent> events;
public void announce() {
events.fire(new LivePriceEvent(
"Digital Java EE", 45.0 ));
}
}

CDI Event Target
@ApplicationScoped public class PriceListener {
public void listenAndReport(
@Observes LivePriceEvent event ){
System.out.printf("event.product = %sn",
event.getProduct());
System.out.printf("event.price = %sn",
event.getPrice());
}
}

Demonstration
View Scoped Form

JSF View Scoped Controller #1
▪ @ViewScoped belongs to JSF specification
▪ Retains the scope lifespan for current page view
▪ If the controller navigates away to a different page
view the bean is de-scoped
▪ Therefore view-scope is great for form validation
and richAJAX request and response sequences!
▪ #Fail for HTTP POST-REDIRECT-GET idiom

JSF View Scoped Controller #2
@Named @ViewScoped class ContactDetailController {
@EJB ContactDetailService dao;
ContactDetail contactDetail = new ContactDetail();
public String createContact() {
dao.add(contactDetail);
contactDetail = new ContactDetail();
return "index.xhtml";
}
}

Flash Scope #1
▪ JSF supports a flash map collection for controllers
▪ Only accessible through FacesContext
1. JSF places the flash data temporarily into the
HttpSession before it creates the Faces Response.
2. A special flash cookie is set before sending a
redirect HTTP response.
3. A HTTP client resends the flash cookie in a Faces
Request. JSF removes the flash cookie.
4. JSF copies the flash session data to request scope
and them removes it from the session scope.

Flash Scope #2
@Named @ViewScoped class FrenchSuitController {
private String firstName, lastName;
public String doAction() {
Flash flash = FacesContext.getCurrentInstance().
getExternalContext().getFlash();
flash.put("firstName",firstName);
flash.put("lastName",lastName);
return "/jsf-validation/french-suit-
complete?redirect=true";
} ...

Flash Scope #3
<ui:define name="mainContent">
<h1> House of Cards with JSF Validation</h1>
<div class="jumbotron">
Terrific! You completed the French suite action.
Your first name is <b>#{flash['firstName']}</b> and
your last name is <b>#{flash['lastName']}</b> and
you chose <b>#{flash['suit']}</b> as the suit.
</div> ...
</ui:define>

JSF 2.2 supports HTML5 content!

HTML5 friendly markup in JSF
2.2
▪ In JSF 2.2, by default XHTML are rendered with
HTML5 <DOCTYPE html>
▪ Pass-through attributes
▪ Pass-through elements

Pass-through attributes
<html xmlns="http://www.w3.org/1999/xhtml" ...
xmlns:p="http://xmlns.jcp.org/jsf/passthrough">
<div class="col-sm-9">
<h:inputText p:type="date"
class="form-control" id="birthday"
value="#{customerController.birthday}"
p:placeholder="1977-10-25” />
</div>

Pass-through elements
<html xmlns="http://www.w3.org/1999/xhtml” ...
xmlns:jsf="http://xmlns.jcp.org/jsf">
<head jsf:id="head"> ... </head>
<body jsf:id="body">
<form jsf:id="vacationForm">
...
<input type="text" jsf:id="companyId"
placeholder="Your company identity number”
jsf:value="#{vacationController.companyNo}” />

Conversations

Demonstration
Instant Smart Secure

Conversation scope
▪ A lifespan sits between a Http Request scope and
Http Session scope
▪ Maintains state for the unique interaction
▪ Works for individual tab in web browsers
▪ Better than @ViewScoped bean controllers
▪ Application defined lifespan

Conversation scoped bean #1
public interface Conversation {
void begin();
void begin(String id);
void end();
String getId();
long getTimeout();
void setTimeout(long milliseconds);
boolean isTransient();
} // import javax.enterprise.context.*;

@Named @ConversationScoped
public class LendingController
implements Serializable {
@EJB ApplicantService applicantService;
@Inject Conversation conversation;
public String doConfirm() { ... }
}

@Named @ConversationScoped class LendingController ... {
public void checkAndStart() {
if ( conversation.isTransient()) conversation.begin();
recalculatePMT();
}
public void checkAndEnd() {
if (!conversation.isTransient()) conversation.end();
}
}

class LendingController ... {
public String doLandingPage() {
checkAndStart();
return "your-details?faces-redirect=true";
}
...
}

class LendingController ... {
public String doCancel() {
checkAndEnd();
return "index.xhtml?faces-redirect=true";
}
...
}

Conversation scope
conclusions
Pros
▪ Conversation scope is great for “wizards”
▪ Linear sequence of pages
▪ Conversation is unique per tab
▪ Application defines the entry & exit points
Cons
▪ Explicitly termination of conversation
▪ Customer jumps away and back again

JSF 2.2 Faces Flows

Flow scope #1
▪ Brand new scope in JSF 2.2 and Java EE 7
▪ Modular in execution
▪ Concept of nodes
▪ Associated with a URI path

Flow scope #2
▪ Flows can nested; a flow can invoke another
▪ Parameters and data can pass to and back through
Flow scope map collection
▪ package javax.faces.flow.*

Flow scope #3
▪ A Flow is a folder name in your web context
application
▪ A Flow must have a Flow Definition XML file that
matches the folder name
▪ <Flow-Name>/<Flow-Name>-flow.xml
▪ This file can be blank – implicit flow navigation

Flow node types
▪ View – represents any JSF page view
▪ Method Call – method invocation through EL
(expression language)
▪ FlowCall – invocation of another flow with inbound
and outbound parameters
▪ Flow Return – return to the calling flow
▪ Switch – navigation selection through EL

sector-flow
carbon-footprint-flow
Start
End

Demonstration
Flow scope application

Flow layout project
src/main/webapp/sector/
src/main/webapp/sector/sector-flow.xml
src/main/webapp/sector/sector.xhtml
src/main/webapp/sector/sector-page-1a.xthml
src/main/webapp/sector/sector-page-1b.xthml
src/main/webapp/sector/sector-page-1c.xthml

Flow layout project #2
src/main/webapp/footprint/
src/main/webapp/footprint/footprint-flow.xml
src/main/webapp/footprint/footprint.xhtml
src/main/webapp/footprint/footprint-page-1a.xml
src/main/webapp/endflow.xhtml

Flow scoped controller #1
@Named @FlowScoped("sector")
public class SectorFlow
@Inject UtilityHelper utilityHelper;
@Inject CarbonFootprintService service;
public SectorFlow() { ... }
}

@Named @FlowScoped("sector")
public class SectorFlow
@Inject UtilityHelper utilityHelper;
@Inject CarbonFootprintService service;
public SectorFlow() { ... }
}

public class SectorFlow ...{
@PostConstruct
public void initialize() {
footprint.setApplicationId(
utilityHelper.getNextApplicationId());
}
...
}

public class SectorFlow ...{
public String gotoEndFlow() {
return "/endflow.xhtml";
}
public String saveFootprintRecord() {
service.add(footprint);
return "sector-page-1c.xhtml";
}
}

Flow definition XML file #1
<faces-config version="2.2" ...>
<flow-definition id="sector">
<flow-return id="goHome">
<from-outcome>/index</from-outcome>
</flow-return>
...
</flow-definition>
</faces-config>

<flow-definition id="sector">
<flow-return id="endFlow">
<from-outcome>#{sectorFlow.gotoEndFlow()}
</from-outcome>
</flow-return>
<flow-call id="callFootprintFlow”>...</flow-call>
</flow-definition> ...
</faces-config>

<flow-call id="callFootprintFlow">
<flow-reference><flow-id>footprint</flow-id>
</flow-reference> ...
<outbound-parameter>
<name>param3FromSectorFlow</name>
<value>#{sectorFlow.footprint}</value>
</outbound-parameter>
</flow-call>
</flow-definition>
</faces-config>

Nested flow scope #1
@Named @FlowScoped("footprint")
public class FootprintFlow implements Serializable {
private CarbonFootprint footprint;
@PostConstruct public void initialize() {}
Map<Object,Object> flowMap =
FacesContext.getCurrentInstance()
.getApplication().getFlowHandler()
.getCurrentFlowScope();
footprint = (CarbonFootprint) flowMap.get("param3Value");
}

public class FootprintFlow ... {
public String exitFromFootprintFlow() {
return ”/sector";
}
. . .
}

public class FootprintFlow ... {
. . .
public String gotoPage2() {
return "footprint-page-1a";
}
}

Nested Flow definition XML
file #1
<flow-definition id="footprint-flow">
<flow-return id="goHome">
<from-outcome>/index</from-outcome>
</flow-return>
...
</faces-config>

file #2
<flow-definition id="footprint"> ...
<flow-return id=”exitToCallerFlow">
<from-outcome>#{footprintFlow.exitFromFootprintFlow}
</from-outcome>
</flow-return>
<flow-return id="exitToSectorFlow">
<from-outcome>/sector-flow</from-outcome>
</flow-return>

file #3
<flow-definition id="footprint"> ...
<inbound-parameter>
<value>#{flowScope.param1Value}</value>
</inbound-parameter> ...
<inbound-parameter>
<value>#{flowScope.param3Value}</value>
</inbound-parameter>

Flow scope bean conclusions
Pros
▪ Conversation scope is great for “wizards”
▪ Flow node demarcated by URI folder convention
▪ Nestable flow customer journeys
Cons
▪ Handling REDIRECT is difficult (JSF 2.3 perhaps?)
▪ Flow scope parameter passing can be peculiar
▪ Only one START NODE and not configurable

Choosing a scope for a
managed bean controller
▪ Sharing data, utility and information for all users,
prefer @ApplicationScoped
▪ Sharing information and behavior for an individual
customer, prefer @SessionScoped
▪ Customer journey restricted to a specific set of page
views, choose @FlowScoped
▪ Defined customer journey and custom application
entry and exit points, choose @ConversationScoped
▪ Basic rich validation entry and exit point, prefer
@ViewScoped

Adding Finesse
▪ Consider CSS framework such as Bootstrap
(http://getbootstrap.com) or Foundation
(http://foundation.zurb.com/ )
▪ Consider SASS or LESS for CSS templates
▪ Learn JavaScript programming
▪ Maybe learn aboutTranspilers
▪ Consider RequireJS (http://requirejs.org/) for
organising JavaScript modules

Design considerations
▪ Evolution of object oriented JavaScript leads to rich
frameworks inside the client’s web browser
▪ JSF lends itself to page view navigation
▪ Hybrid design is possible with JSF and adopting
JavaScript controller
▪ JSF 2.2 Faces Flows is a major feature worthy of
investigation

Non-Functional Requirement
HealthCare.gov site must
handle 10,000 customers at
once.

It failed with just a few
hundred users.

HealthCare.gov (USA)
Website cost $300 million price tag

Don’t worry USA!
British NHS IT system was abandoned after 10 years
and cost the tax payer £10bn so far

▪ Innovate with optionality
▪ Constraints
▪ Build fast, fail fast
▪ Communication
▪ Technology == evolution

Executive Summary
Hints and tips and where to go next

Conclusions
▪ Leverage Java EE 7 platform
▪ Choose scope by lifespan of the bean
▪ Prefer Faces Flows for digital customer journeys
▪ Otherwise Conversation-Scoped beans
▪ Prefer HTML5 friendly markup of Facelets views
▪ Prefer CDI

Conclusions #2
▪ Protect your from UX changes
▪ Keep action controller methods short
▪ Delegate complex logic to business logic
▪ Use DOMAIN MODEL CONTEXT objects
▪ Avoid methods with long parameter lists!
▪ Inject DOMAIN MODEL LOGIC

Contacts
▪ Follow me onTwitter @peter_pilgrim
▪ Read my blog http://xenonique.co.uk/blog/
▪ Books from Packt Publishing
–Digital Java EE 7
–Java EE 7 Developer Handbook

Photo credits (cc) 2016
▪ by Joshua Earle https://unsplash.com/joshuaearle
▪ By Lili Popper https://unsplash.com/lili_popper
▪ By Rowan Heuvel https://unsplash.com/insolitus
▪ By David Marcu https://stocksnap.io/author/302

▪ By Gemma Bou (hand fractal)
https://www.flickr.com/photos/gemmabou/
▪ By Nicole Hanusek (luggage)
https://www.flickr.com/photos/nhanusek/
▪ By Navaneeth KN (group photo painted stork)
https://www.flickr.com/photos/navaneethkn/
▪ By Ruben Schade (container ship in the Straits of
Singapore) https://www.flickr.com/photos/rubenerd/

▪ Joel Cooper (big face 1)
https://www.flickr.com/photos/origamijoel/
▪ Nullfy from nullfy.com! (Ring of Power!)
https://www.flickr.com/photos/130197050@N04/
▪ philippe leroyer (Student Demonstration (46) - 27Nov07, Paris
(France)) https://www.flickr.com/photos/philippeleroyer/
▪ philippe leroyer (Pupil's Demonstration (10) - 10Apr08, Paris
(France)) https://www.flickr.com/photos/philippeleroyer/

JavaOne 2015 CON5211 Digital Java EE 7 with JSF Conversations, Flows, and CDI Scopes

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to JavaOne 2015 CON5211 Digital Java EE 7 with JSF Conversations, Flows, and CDI Scopes

Similar to JavaOne 2015 CON5211 Digital Java EE 7 with JSF Conversations, Flows, and CDI Scopes (20)

More from Peter Pilgrim

More from Peter Pilgrim (12)

Recently uploaded

Recently uploaded (20)

JavaOne 2015 CON5211 Digital Java EE 7 with JSF Conversations, Flows, and CDI Scopes

Editor's Notes