Delegate's primary purpose is to serve as a bridge between an event-driven front-end and a multithreaded middle tier. In Swing, when an event is triggered, it does not execute right away. Instead, it joins the event queue (java.awt.EventQueue) where it waits along with other events to be executed by the Event-Dispatch Thread (EDT). The EDT pulls events off the queue and services them one-by-one.
An event that requires a significant time to complete - either because it's computationally intensive or because it makes blocking calls - holds up the rest of the queue, causing the user interface to seem sluggish. In fact, since repaint requests traverse the queue as well, expensive events typically cause components to appear as lifeless solid-colored rectangles.
If an event can't be processed in a timely fashion, it should forward the request to a worker thread. That's the reason why Delegate provides invokeAsync(). invokeAsync() is called just like invoke(), but it dispatches a java.util.concurrent.ThreadPoolExecutor thread to execute the method. Since it's an asynchronous call, it returns immediately without a return value. To see this in use, here's an indirect call to println() on a different thread:
Delegate delegate = new Delegate(
System.out, "println");
delegate.invokeAsync("Hello World!");
Now, Swing components aren't thread-safe; they were designed to be accessed exclusively by the EDT. To safely call Swing methods from worker threads, Delegate provides invokeUI(). If invokeUI() is called by the EDT, the method is invoked directly. Otherwise, a request to execute the method is placed in the event queue. Since the call is potentially asynchronous, invokeUI() doesn't return a value. On the other hand, Delegate.invokeUIAndWait() enqueues the request, blocks until the EDT fulfills it, and then returns the result. The following example demonstrates how to obtain a JTextField value safely from any thread:
Delegate delegate = new Delegate(
textField, "getText");
String text = (String)delegate
.invokeUIAndWait();
A Listener Delegate
To join Swing events with methods, I combined delegates with a dynamic proxy. The dynamic proxy is an often-overlooked concept that's been available since Java 1.3. Before I discuss it, let's quickly review the proxy pattern.
A proxy acts as a middleman, serving as a stand-in for another object. Typically that other object and the proxy share a common interface. In the case of Remote Method Invocation (RMI), for example, you access a remote object living in a JVM on a different machine across the network via a local proxy. Internally, the local proxy forwards all method calls to the remote counterparts. The proxy effectively creates the illusion that the remote class is accessible locally.
For Swing components, I needed a proxy with the ability to stand-in for any event listener. I could have created a class that implements all of the listener interfaces in java.awt.event and forwards the calls to Delegate.invoke() accordingly, but that would have required way too much typing.
Luckily, java.lang.reflect.Proxy provides a static newProxyInstance() method for generating a proxy class on-the-fly that implements a specified set of interfaces - hence the term "dynamic proxy." newProxyInstance() requires a ClassLoader, a list of interfaces as a Class[], and a reference to an InvocationHandler implementation. InvocationHandler contains a single method with this signature:
public Object invoke(Object proxy,
Method method, Object[] args)
throws Throwable
All calls on the dynamically created proxy funnel down to InvocationHandler.invoke() where the Method parameter contains a description of the invoked proxy method. It's a simple matter to use it along with args to make a Delegate.invoke() call.
To generate dynamic proxies, I created a factory class called UIDelegate. Listing 2 shows one of its static create() methods. The return type, UIDelegateListener, is an interface that extends all of the interfaces in java.awt.event. UIDelegateProxy is an inner class that implements InvocationHandler.
The create() method accepts an arbitrary number of arguments in groups of four, each corresponding to a method of an event listener interface. A group consists of the object with a handler method, the name of the event method, the name of the handler method, and the technique to call the handler. The last parameter is a boolean: true indicates that the handler is invoked asynchronously and false causes the EDT to invoke it directly. The following example shows how to associate a handleOK() method with a button:
okButton.addActionListener(UIDelegate
.create(this, "actionPerformed",
"handleOK", true));
The referenced handleOK() method must accept an ActionEvent.
For those listeners with multiple methods, you only need to specify the methods that you're interested in. For example, MouseListener provides five methods, but if you only need to respond to enter and exit events on the EDT, you can do it like this (see Figure 2):
panel.addMouseListener(new UIDelegate(
this, "mouseEntered", "handleEnter",
false, this, "mouseExited",
"handleExit", false));
Subscribe to JAVA Developer's Journal Email News Alerts
Subscribe via RSS
