Effective JavaFX architecture with FxObjects

Effective JavaFX
Architecture with

Presented by
Srikanth Shenoy
ObjectSource
(Covers FxObjects 0.1)

Introduction
 Who am I?
 A hands-on architect
 Experienced and very knowledgeable in Java and
Java EE
 Authored a book on Struts
 Several articles on Java EE for leading journals
 Director of Enterprise Java Practice at
ObjectSource
 Creator of FxObjects framework

Introduction
 What is FxObjects? (Currently 0.1)
 An open source JavaFX application development
framework (Apache License)
 Why FxObjects?
 Enterprise JavaFX architect/developer starts from
scratch, reinventing the wheel, wasting time and
repeating mistakes
 Enterprise JavaFX applications need a strategic
and functional framework (not a point solution).
 FxObjects is that strategic functional framework !
 Learn FxObjects in 25 slides !

Introduction
 FxObjects is the end to end application
development framework in the UI tier.
 Designed to simplify large JavaFX application
development
 Makes your application elegant by using
proven patterns, principles and practices
 If you use FxObjects as defined in the user
guide, your application becomes inherently
test friendly

Introduction
 FxObjects is Dependency Injection (DI)
friendly from the grounds-up.
 Tested with Spring 2.5
 Dependency Injection + FxObjects makes a
very powerful and agile programming model
 FxObjects makes TDD possible with JavaFX
by using Model-View-Presenter (MVP)
 FxObjects is NOT a UI component library
(and never intends to be).

Model-View-Presenter
(Passive View)

 Note the sequence of events in MVP passive
View
 Actual UI is lean, mean and clean 
 Presenter does the heavy lifting on the UI
side. But Presenter is not really a UI !!
 Hence Presenter can be easily tested and
asserted

MVP with FxObjects
 NodePresenter is the FxObjects class.
 MyNodePresenter and MyNode are app
classes & hold reference to each other
 When a event occurs, the MyNode simply
calls doOnSearchButtonClick()

Presenter Code
 doSearchButtonClick method
 Validates UI (for mandatory fields)
 Calls the service asynchronously using FxObjects
Command classes
 That’s it!
 You will see FxObjects Commands next
 For aiding the async service calls
 Update the UI when async calls return data
 Show error message when service call fails

Challenges in Service
Invocation
 Async calls are fire and forget
 They should execute off the Event Dispatch
Thread (EDT)
 All UI updates should then again occur ON
the EDT.
 Can be confusing and errror-prone
 Swing provided SwingWorker
 JavaFX provides a async framework
 Slightly complex, but FXObjects simplifies this

Challenges in Service
Invocation (contd.)
 HttpRequest (core JavaFX class) has some
solution (async call is off-EDT & callbacks are
on-EDT), but it is the foundation for a full
solution
 FxObjects HttpCommands provide the
missing pieces to make this simple
 How to easily go to another page v/s stay on
same page after service invocation?
 FxObjects solves this, as we shall see soon
(controller chain)

Command objects
 Command objects are configured first and
then executed [with execute(..) method]
var cmd = DefaultAsyncCommand {
runInBackground: function(modelObj:Object):Object {
//call service here
}
onSuccess: function(resultObj:Object):Void {
//update ui widgets here OR navigate to another UI
}
onError: function(e:Exception):Void {
//show the error
}
}

Automating XML to JavaFX
 No Xml tag handling code necessary
 Use XmlResponseBuilder
 Called ResponseBuilder since it was initially
built to construct JavaFX objects from XML
content (returned by REST services)
 Can handle XML of any type and of any
depth
 Scales well for all kinds of xml
 Best suited for small JavaFX apps though
 Larger apps can use JAXBResponseBuilder

Automating JavaFX to XML
 No code necessary
 Use XmlRequestBuilder
 Called RequestBuilder since it was initially
built to construct XML from JavaFX objects to
be sent as request body to REST services
 Can handle JavaFX objects of any type and
of any depth
 Scales well for JavaFX objects of any kind
 Best suited for small JavaFX apps
 Larger apps can use JAXBRequestBuilder

HttpCommands and Builders
 Just like DefaultAsyncCommand
 No runInBackground necessary. [Http
GET/POST themselves run in background !!]
 Url & query parameters are configurable with
{ } syntax
 e.g. http://server/app/search?zipCode={zipCode}
 The params in {} can be passed in a Map
 Otherwise reflection is used to query the object
 Need RequestBuilder and ResponseBuilder
 XML***Builder or JAXB***Builder

GetHttpCommand
var respBuilder = new MyJAXBResponseBuilder();
respBuilder.setSchema(…);
var cmd = GetHttpCommand {
urlTemplate: “http://.../Search?output=xml&zip={zipCode}&..
responseBuilder: respBuilder
onSuccess: function(resultData:Object) {
var result = resultData as ResultSet;
//update UI components here OR navigate to another UI
}
onError: function(e:Exception) {
..
}
}
..
function doSearchButtonClick() {
var paramMap = new HashMap();
paramMap.put(“zipCode”, node.zipCodeTxtBox.text);
cmd.execute(paramMap);
}

Custom JAXB Response
Builder
public class CafeSearchResponseBuilder extends
JAXBResponseBuilder<ResultSet> {
@Override
public ResultSet buildResponse(String serverResponse) {
ResultSet rs =
buildResponseObjectFromXml(serverResponse);
return rs;
}

@Override
public ResultSet buildResponse(InputStream inputStream) {
ResultSet rs = buildResponseObjectFromXml(inputStream);
return rs;
}
}

BodyHttpCommand
 Use for PUT and POST
 Almost same as GetHttpCommand
 Additionally needs RequestBuilder
 To convert the presentation model object into
format expected by server (Generaly XML)
 Optionally a content pre-processor
 To massage the output from the requestbuilder
and before sending to server

Navigation challenges
 How to go to another page v/s stay on same
page after service invocation succeeds?
 Default JavaFX model involves binding to a
new scenegraph
 Couples the lower level UI to top level stage.
 No idioms for organizing the application into
modules
 Who decides what is the default node to
display?
 Solution: FxObjects ControllerChain

Navigation with FxObjects
Controller Chain
 Each Application can hold many Presenters
 Each Application can have many Modules
 Each Module can hold many Presenters
 Application has a Application Controller
 Each Module has a Module Controller.
 Module Controller has a Id
 Each NodePresenter owns the Node
 Node Presenter has a Id

Navigation with FxObjects
Controller Chain (contd.)
public MyNodePresenter extends NodePresenter
var cmd = DefaultAsyncCommand {
runInBackground:function(modelObj:Object):Object {
//call service here
}
onSuccess: function(resultObj:Object):Void {
//update ui here OR go to another page
this.changeNodePresenter(“someNodePresenterId”);
}
onError: function(e:Exception):Void {
//show the error
}
}
changeNodePresenter(..) is defined in NodePresenter class (the parent)

FxObjects and Dependency
Injection
 FxObjects is built with Dependency Injection
in mind.
 DI is optional, but recommended
 What can be wired
 ApplicationController, ModuleController
 NodePresenter (but not Nodes)
 Commands, Services (Service Proxies)
 Nodes should be maintained by Presenters.
 This lets presenters choose appropriate node
handling strategy (cache, dispose after use etc.)

Bootstrapping FxObjects
var ctx = new ClassPathXmlApplicationContext(“/your-spring.xml");
var appController =
ctx.getBean("appController") as ApplicationController;

Stage {
title: "FxObjects Example“
scene: Scene {
width: 600
height: 400
content: bind [
appController.currentNodePresenter.getNode()
]
}
}
 Node presenter configured as default is shown at the beginning
 Every navigation call sets another NodePresenter as the “Current”
NodePresenter and that gets bound to the scenegraph

What’s coming in 0.2?
 Lifecycle
 Event
 Event Bus
 Security
 JSON to JavaFX round-tripping
 Suggestions welcome (Please post in the
discussion forums)
 Timeframe: September 2010

FxObjects Summary
 Enterprise JavaFX applications are inherently
complex.
 Architecting such apps is art and science
 FxObjects can help
 The more complex the application, the more
value you get from FxObjects
 End to end programming model for the UI
 Does not force any programming model for
the server

Links
 Project site – https://fxobjects/dev.java.net
 Not a single person open source project
 FxObjects is developed and supported by
ObjectSource (http://www.objectsource.com)
 Download, use, extend, redistribute, OEM
 Discussion Forums on project site
 We will answer your questions
 Participation welcome
 Post ideas, questions, concerns, comments
 Contribute code

Effective JavaFX architecture with FxObjects

More Related Content

What's hot

Viewers also liked

Similar to Effective JavaFX architecture with FxObjects

Recently uploaded

Effective JavaFX architecture with FxObjects