Question

In the Google Guava EventBusExplained page, I don’t understand when they say the following:

To listen for a common event supertype (such as EventObject or
Object)…
…in traditional Java events: not easy.

…with EventBus:
events are automatically dispatched to listeners of any supertype,
allowing listeners for interface types or “wildcard listeners” for
Object.

1. What does it mean to listen for a common event supertype?
2. When they mention EventObject , are they talking about java.util.EventObject?
3. What does it mean to allow “listeners for interface types or “wildcard listeners” for Object”?

Answer 1

This has to do with the limitations of method-overloading and interfaces that Guava’s EventBus class can overcome.

For interfaces, consider the following scenario:

I have the same code that gets invoked for multiple forms of input. For example, a listener that listens to mouse events, key events, and focus events, but all methods do the same thing: repaint the source. This would mean that my code would look like this:

public class BunchOfListeners implements MouseListener, KeyListener, FocusListener {

    @Override
    public void focusGained(FocusEvent e) {
        doSomething(e);
    }

    @Override
    public void focusLost(FocusEvent e) {
        doSomething(e);
    }

    @Override
    public void keyTyped(KeyEvent e) {
        doSomething(e);
    }

    @Override
    public void keyPressed(KeyEvent e) {
        doSomething(e);
    }

    @Override
    public void keyReleased(KeyEvent e) {
        doSomething(e);
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        doSomething(e);
    }

    @Override
    public void mousePressed(MouseEvent e) {
        doSomething(e);
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        doSomething(e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        doSomething(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        doSomething(e);
    }

    public void doSomething(EventObject e) {
        ((Component) e.getSource()).repaint();
    }
}

Notice how ugly this is? There are 10 different methods for this, when ultimately the only thing we care about is getting the source off the event (which is specified by EventObject, by the way, which is why they used that in their example) and calling repaint on it.

With Guava’s EventBus, this gets super, super simple. All I need in my GuavaIsAwesome ComponentRepainter class is one method:

public class ComponentRepainter {

    @Subscribe
    public void doSomething(EventObject e) {
        ((Component) e.getSource()).repaint();
    }
}

When you register this with an EventBus and later fire, say, a MouseEvent on it:

EventBus eventBus = ... ;
eventBus.register(new ComponentRepainter());

And later:

MouseEvent e = ... ;
eventBus.post(e);

This will call the doSomething method on ComponentRepainter because it will not only fire the event to @Subscribe methods with MouseEvent for the parameter, but also to any methods that have a parameter that is assignable from MouseEvent. In other words, because MouseEvent extends EventObject, Guava’s EventBus will pass it to anything that accepts EventObject. If we made doSomething accept Object, then we can get every event that’s posted to the EventBus, making it a sort of global listener (because everything in Java extends Object).

The same thing applies to interfaces as well. If you pass a concrete implementation to EventBus of some interface, then @Subscribe methods that use the interface (as opposed to the concrete type) will be called. It’s much more flexible, and overcomes the “10 useless methods” approach.