(April 24, 2003) - While designing Enterprise frameworks, you ought to be very cautious about exposing runtime instances of classes encompassing secure transaction or management core, outlining Intellectual Property of the enterprise. Often it is required to create a proxy wrapper around objects so method-invoke requests can be pre-processed before being associated with the original instance. Very few Java developers are accustomed to abstract their management objects by creating dynamic proxy wrappers.

java.lang.reflect.Proxy class provides methods for creating dynamic proxy classes. A Proxy object implements a list of interfaces specified at runtime, when the proxy is created. When you invoke a method on a proxy instance, an associated invoke method of the proxy class gets called with the aid of the InvocationHandler interface. Each proxy object has an associated invocation handler. When a method is invoked on a proxy object, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

That said, let's create a simple interface with a method, which prints a string. We shall also create a proxy wrapper, which will let us perform some custom action before and after invoking the method.

Note: Proxy class and InvocationHandler interface are from JDK 1.3

A simple interface having a single method.

public interface JDJ{
void hello(String str);
}


Implementation for our JDJ Interface
public class JDJImpl implements JDJ{
public void hello(String str){
System.out.println("Hello..."+str);
}
}

Let us create a proxy wrapper for our JDJ Interface so that we can perform some processing before and after the method invocation.

import java.lang.reflect.*;

public class JDJProxy implements InvocationHandler{

Object myo;

public JDJProxy (Object ob){
myo = ob;
}

/*
InvocationHandler.invoke( ) processes a method invocation
on a proxy instance and returns the result
*/

public Object invoke (Object jdjp, Method me, Object [] ars) throws Throwable{
Object obj = null;

try{
/* How about method pre-processing here? */
System.out.println("Wait...Proxy invoking method...");
obj = me.invoke (myo, ars);
}
catch(Exception e){
System.out.println("Remote Object invoke failure!");
}

finally{
/* How about method post-processing here? */
System.out.println("Wait...Proxy cleaning up...");
}

return obj;
}
}

We have created a proxy wrapper successfully! Now let us try to invoke the abstracted method.

import java.lang.reflect.*;

public class JDJAccess{
public static void main(String ar[]){

/* Let us set up a proxy wrapper for our
interface
*/
Proxy pr = null;
ClassLoader cl = JDJ.class.getClassLoader();
Class[] cls = new Class[] {JDJ.class};
InvocationHandler ih = new JDJProxy(new JDJImpl());

/* Proxy.newProxyInstance( ) returns an instance
of a proxy class for the specified interfaces
that delegates method invocations
to the invocation handler
*/
JDJ jdj = (JDJ)pr.newProxyInstance(cl, cls, ih);

/* Transparent proxy; invokes the Proxy's invoke
method first
*/
jdj.hello("JDJ");

}
}

Compile all the four files and run JDJAccess. You will get this output:

Wait...Proxy invoking method...
Hello...JDJ
Wait...Proxy cleaning up...

Similarly, you can create a single Proxy wrapper for all interfaces in your framework. These Dynamic Proxies can also be used for logging and debugging method calls, which can be very useful for testing and debugging applications.