Dynamic Proxy

In software design, a proxy pattern is one of the popular GOF design patterns. 

A proxy is a class functioning as an interface to something else, it could be an interface to some business logic, network, file, or anything else.

This can also be seen as a wrapper around something core or real, main goal of a proxy is to add abstraction to get something extra it could be logging, permission check, cache, metric collection, etc.

We interact with proxies in real life. Take a example of bank interaction via ATM

ATM acts like a proxy to the bank branch, it allows to do almost everything that can be done at a branch.

In software we see many variations of a proxy, some of the examples are in IO API in java

Another variation is chain of responsibility.  

In java proxy can be of 2 types it can be static and dynamic, lets look at a static proxy example.

Static Proxy

We are building Big Collection that allows to store unlimited data, our big collection interface looks like

public interface BigCollection<V> {
    void add(V value);

    boolean exists(V value);

    void forEach(Consumer<V> c);
}

Static proxy will have same interface as original interface and will manually delegate calls to real object, it will look something like below.

public class BigCollectionProxy<V> implements BigCollection<V> {

    private final Supplier<BigCollection<V>> supplier;
    private final BigCollection<V> realObject;

    public BigCollectionProxy(Supplier<BigCollection<V>> supplier) {
        this.supplier = supplier;
        this.realObject = supplier.get();
    }

    @Override
    public void add(V value) {
        realObject.add(value);
    }

    @Override
    public boolean exists(V value) {
        return realObject.exists(value);
    }

    @Override
    public void forEach(Consumer<V> c) {
        realObject.forEach(c);
    }
}

Client API for using the proxy will look something like below 

BigCollection<String> collection = new BigCollectionProxy<>(AwsCollection::new);

collection.add("Value1");
collection.add("Value2");

collection.forEach(System.out::println);

System.out.println("Exists " + collection.exists("Value2"));

Static proxy is easy to implement but it has got few problems 

• Manual delegation is painful and very verbose.
• Any changes in interface required proxy also to implement changes.
• Special treatment to functions that are part of language ecosystem like equals, hashcode,getClass etc. 
• and as name suggest it is static, can't change the behavior at runtime.

Dynamic proxy solves issue with static proxy, lets look at dynamic proxy.

Dynamic Proxy

Dynamic proxy creates proxy at runtime, it is very flexible and convenient.

 JDK has dynamic proxy API since 1.3 that allows to create dynamic proxy using very simple API

Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

Lets create dynamic proxy for BigCollection class.

(BigCollection<V>) Proxy.newProxyInstance(BigCollection.class.getClassLoader(),
        new Class<?>[]{BigCollection.class},
        new BigCollectionDynamicProxy(supplier.get()));

This proxy looks exactly like BigCollection implementation and can be passed around. This also does not have the verbosity of static/hand crafted proxy, full proxy looks something like below

public class BigCollectionDynamicProxy implements InvocationHandler {
    private final Object realObject;

    public BigCollectionDynamicProxy(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(realObject, args);
    }

    public static <V> BigCollection<V> create(Supplier<BigCollection<V>> supplier) {
        return (BigCollection<V>) Proxy.newProxyInstance(BigCollection.class.getClassLoader(),
                new Class<?>[]{BigCollection.class},
                new BigCollectionDynamicProxy(supplier.get()));
    }

} 

Java reflection makes it easy to delegate calls to underlying real object.

Dynamic Proxy Use case

Lets look at some use case where dynamic proxy will come handy.

 - Timing of method execution

Elapsed time calculation is one of the cross-cutting concerns and proxy comes in handy for such use cases without the need of adding time tracking code all over the place.

 

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    long start = System.nanoTime();
    try {
        return method.invoke(realObject, args);
    } finally {
        long total = System.nanoTime() - start;
        System.out.println(String.format("Function %s took %s nano seconds", method.getName(), total));
    }
}

 - Single thread execution

Many time some use case need single thread access to critical data structure. Dynamic proxy can add synchronization at the higher level, core code is not worrying about language level synchronization APIs.

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    synchronized (realObject) {
        return method.invoke(realObject, args);
    }
}

 - Asynchronous Execution.

Asynchronous execution is one of the common techniques to get best out of  cores of underlying machine. Java has made parallel computation very easy with Completable future, parallel streams etc. Newer JDK version will have support for fibers and that will add concept of light weight threads.

Dynamic proxy can be used to convert synchronous API to asynchronous with simple code.  

Code snippet for async exeuction.

es.submit(() -> {
    try {
        System.out.println("Using thread " + Thread.currentThread().getName());
        method.invoke(realObject, args);
    } catch (Exception e) {
        e.printStackTrace();
    }

}); 

Few things to understand for such type of scenario

 - Value is not return, client API has to use some mechanism like call back handler or reply API to get value.

 - Exception handling.

 - Logging.

This is straight forward use case and very popular one. 

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    long start = System.nanoTime();
    try {
        return method.invoke(realObject, args);
    } finally {
        long total = System.nanoTime() - start;
        System.out.println(String.format("Function %s took %s nano seconds", method.getName(), total));
    }
}

Dynamic Proxy Tradeoff

Nothing comes for free, dynamic proxy has below tradeoff.

- Reflection cost 

- Parameter box/unboxing

- Array overhead for parameters.

Reflection related cost are not that much of issue in JDK8 onwards. I wrote about reflection in few post.

Java Reflection Facts

Methodhandle returns back in java 8

Boxing & Unboxing overhead are really hard to resolve and this will be always overhead for dynamic proxy unless some code generation technique is used.

Dynamic proxy can be used to build many useful things. In next part of this post i will have more advance usage of dynamic proxy.

Code used in this post is available @ proxy github project