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 (19)

Viewers also liked (13)

Similar to Effective JavaFX architecture with FxObjects (20)

Recently uploaded (20)

Effective JavaFX architecture with FxObjects