API : EventHandler and ugly code

Question

Hello,
I'm playing with javafx2 api since I 've been disapointed by flex and silverlight api.
My reference is forever the swing api and I want to know how to write beautiful code which will respect all best practices (pmd,checkstyle, findbugs, javancss)
The problem is the genericsable class EventHandler ...
In swing I can have a class that implements MouseListener and ActionListener interface, So if my control implements these interfaces I can have an actionPerformed, mouseMoved .... methods which will process all actions.
public class MyClass extends JPanel implements ActionListener, MouseListener {
mybutton.addActionListener(this);
mycontrol.addMouseListener(this);
public void actionPerformed(ActionEvent e){
    if(e.getSource.equals(mybutton)){
         // mybutton stuff
public void mouseMoved(MouseEvent e){
    if(e.getSource.equals(mycontrol)){
         // mycontrol stuff
}The JavaFX2 API use the same approach but since the eventHandler use a custom generics type, I must implements EventHandler (without type <XX>) and do a lot of cast everywhere to fill the gap.
mybutton.setOnAction((EventHandler)this);then
public class ControlPanel extends Region implements EventHandler<Event> {
bt1.setOnAction((EventHandler)this);
bt2.setOnAction((EventHandler)this);
progressbar.setOnMouseClicked(this);
    public void handle(Event event) {
        if(MouseEvent.class.equals(event.getClass())){
            f(event.getSource().equals(progressbar)){
                 //stuff;
        }else if(ActionEvent.class.equals(event.getClass())){
            if(event.getSource().equals(bt1)){
                 //stuff;
            }else if(event.getSource().equals(bt2)){
                //stuff;
    }IN fact with javafx2 it's more difficult to write code not using anonymous class which will be a very big problem for software maintainability and source code quality.
Moreover the SetONXXX method which have a Runnable argument need anonymous class or dedicated inner class to manage threading priorities and I don't see any solution to make it cleaner.
It would be nicer to use a custom Runnable class which have some fields used to identify the source and the kind of event.
At the moment, a javafx2 developers have 2 options :
_ Write a lot of anonymous class anywhere in its source code, the class will be unreadable because the code is not organized (components initialization, action processes, business logic)
_ create a huge amount of dedicated class (runnable and eventhandler) which all reference the main control ...
JavaFx2 code will be more complex and can be less adopted or misloved ....
What do you think about this ?
Edited by: Seb on 27 août 2011 00:15

Answer 1

I do like a good architecture debate, everyone gets so passionate! :)
Pure OO or otherwise, I feel your pain Sebastian: inner classes can be painful to work with. As mentioned above, (IMHO) this is mostly a result of Java's syntax being a little clunky in this area. What you really want to do is pass in a method pointer like this:
void buildView() {
    Button myButtton = new Button();
    myButton.addActionHandler(onMyButtonAction);
void onMyButtonAction(ActionEvent event) {
    // do custom event handling
} But obviously Java doesn't support this at a language level. It does support it via Reflection however and in Swing (and now in JFX) I've often created a helper class that would let me bind the action to the method via Reflection (using inner classes internally - but this is all hidden under the helper).
void buildView() {
    Button myButtton = new Button();
    bindAction(myButton.onActionProperty(), this, "onMyButtonAction");
void onMyButtonAction(ActionEvent event) {
    // do custom event handling
} Your code is now much simpler and more readable but the big (BIG!) drawback is that you lose compiler safety - it is up to you to decide whether this is worth it or not (I'm sure purists will passionately hate this idea but I'm all for 'developers choice').
A simple implementation of the helper code would look something like:
public void bindAction(ObjectProperty<EventHandler<ActionEvent>> onActionProperty, final Object target, final String methodName)
    final Method method = target.getClass().getMethod(methodName, EventHandler.class);
    onActionProperty.set(new EventHandler<ActionEvent>()
        public void handle(ActionEvent event)
            method.invoke(target, event);
}I've left out exception handling for simplicity. You could obviously add a bindMouseClick method, and bindXYZ methods for all the other events that you want to handle.
There's also an [url http://download.oracle.com/javafx/2.0/fxml_get_started/jfxpub-fxml_get_started.htm]emerging option with FXML, that does similar action to method binding. When you define your button in the XML you add a onAction="#myButtonHandlerMethod" and the FXML binder will bind this automagically to your method (I imagine using reflection like I have done above). It's still pretty raw and you have to build your UI layout in XML (a plus in some people's eyes, a negative in others) but it's worth a look. I haven't seen Mouse handler stuff in there yet but if it's not there yet, I imagine it will be added before too long.
Like all free advice, take it or leave it :)
Enjoy,
zonski