Dynamic proxies

Proxy is one of the basic design pattern. It is an object that you insert in place of the "real" object in order to provide additional or different operations--these usually involve communication with a "real" object, so a proxy typically acts as a go-between. Here's a trivial example to show the structure of a proxy:

//: typeinfo/SimpleProxyDemo.java 
import static net.mindview.util.Print.*; 
 
interface Interface { 
  void doSomething(); 
  void somethingElse(String arg); 
} 
 
class RealObject implements Interface { 
  public void doSomething() { print("doSomething"); } 
  public void somethingElse(String arg) { 
    print("somethingElse " + arg); 
  } 
}  
  
class SimpleProxy implements Interface { 
  private Interface proxied; 
  public SimpleProxy(Interface proxied) { 
    this.proxied = proxied; 
  } 
  public void doSomething() { 
    print("SimpleProxy doSomething"); 
    proxied.doSomething(); 
  } 
  public void somethingElse(String arg) { 
    print("SimpleProxy somethingElse " + arg); 
    proxied.somethingElse(arg); 
  } 
}  
class SimpleProxyDemo { 
  public static void consumer(Interface iface) { 
    iface.doSomething(); 
    iface.somethingElse("bonobo"); 
  } 
  public static void main(String[] args) { 
    consumer(new RealObject()); 
    consumer(new SimpleProxy(new RealObject())); 
  } 
} /* Output: 
doSomething 
somethingElse bonobo 
SimpleProxy doSomething 
doSomething 
SimpleProxy somethingElse bonobo 
somethingElse bonobo 

because consumer accepts an Iterface, it can't know if it's getting a RealOjbect or a SimpleProxy, because both implements the Interface. But the SimpleProxy inserted between the client and the RealObject performs operations and then calls the identical method on a RealObject.
A proxy can be helpful anytime you'd like separate extra operation into a different place than the "real object" and especially when you want to easily change from not using the extra operations to using them, and vice versa. For example, what if you wanted to track calls to the methods in the RealObject, or to measure the overhead of such calls? This is not code you want to have incorporated in your application, so porxy allows you to add and remove it easily.

Java's dynamic proxy takes the idea of a proxy one step further, by both creating the proxy object dynamically and handling calls to the proxied methods dynamically. All calls made a dynamic proxy redirected to a single invocation handler, which has the job of discovering  what the call is and deciding what to do about it. Here is SimpleProxyDemo.java rewritten to user a dynamic proxy.

//: typeinfo/SimpleDynamicProxy.java 
import java.lang.reflect.*; 
 
class DynamicProxyHandler implements InvocationHandler { 
  private Object proxied; 
  public DynamicProxyHandler(Object proxied) { 
    this.proxied = proxied; 
  } 
  public Object 
  invoke(Object proxy, Method method, Object[] args) 
  throws Throwable { 
    System.out.println("**** proxy: " + proxy.getClass() + 
      ", method: " + method + ", args: " + args); 
    if(args != null) 
      for(Object arg : args) 
        System.out.println("  " + arg); 
    return method.invoke(proxied, args); 
  } 
}  
 
class SimpleDynamicProxy { 
  public static void consumer(Interface iface) { 
    iface.doSomething(); 
    iface.somethingElse("bonobo"); 
  } 
  public static void main(String[] args) { 
    RealObject real = new RealObject(); 
    consumer(real); 
    // Insert a proxy and call again: 
    Interface proxy = (Interface)Proxy.newProxyInstance( 
      Interface.class.getClassLoader(), 
      new Class[]{ Interface.class }, 
      new DynamicProxyHandler(real)); 
    consumer(proxy); 
  } 
}

You create a dynamic proxy by calling the static method Proxy.newProxyInstance(), which requires a class loader, a list of interfaces that you wish the proxy to implement, and an implementation of the interface InvocationHandler. The dynamic proxy will redirect all calls to the invocation handler, so the constructor for the invocation handler is usually given the reference to the "real" object so that it can forward requests once it performs its intermediary task.

The invoike() method  is handed the proxy object, in case you need to distinguish where the request came from -- but in many cases you won't care. However, be carefull when calling methods on the proxy inside invoke(), because calls through the interface are redirected through the proxy.

In general you will perform the proxied operation and then use Method.invoke() to forward the request to the proxied  object, passing the necessay arguments. This may initially seem limiting, as if you can only perform generic operations. Howere, you can filter for certain method calls, while passing others through:

 
class MethodSelector implements InvocationHandler { 
  private Object proxied; 
  public MethodSelector(Object proxied) { 
    this.proxied = proxied; 
  } 
  public Object 
  invoke(Object proxy, Method method, Object[] args) 
  throws Throwable { 
    if(method.getName().equals("interesting")) 
      print("Proxy detected the interesting method"); 
    return method.invoke(proxied, args); 
  } 
}  
  
interface SomeMethods { 
  void boring1(); 
  void boring2(); 
  void interesting(String arg); 
  void boring3(); 
} 

 
class Implementation implements SomeMethods { 
  public void boring1() { print("boring1"); } 
  public void boring2() { print("boring2"); } 
  public void interesting(String arg) { 
    print("interesting " + arg); 
  } 
  public void boring3() { print("boring3"); } 
}  
  
class SelectingMethods { 
  public static void main(String[] args) { 
    SomeMethods proxy= (SomeMethods)Proxy.newProxyInstance( 
      SomeMethods.class.getClassLoader(), 
      new Class[]{ SomeMethods.class }, 
      new MethodSelector(new Implementation())); 
    proxy.boring1(); 
    proxy.boring2(); 
    proxy.interesting("bonobo"); 
    proxy.boring3(); 
  } 
} /* Output: 
boring1 
boring2 
Proxy detected the interesting method 
interesting bonobo 
boring3 

The dynamic proxy is not a tool that you'll use every day, but it can solve certain types of problems very nicely.