Dynamic Proxy!

The Proxy pattern is one of the most important design patterns because it provides an alternative to extending functionality with inheritance. That alternative is object composition, where an object (proxy) forwards method calls to an enclosed object (real subject).

Object composition is preferable to inheritance because, with composition, enclosing objects can only manipulate their enclosed object through the enclosed object's interface, which results in loose coupling between objects. In contrast, with inheritance, classes are tightly coupled to their base class because the internals of a base class are visible to its extensions.

Because of that visibility, inheritance is often referred to as white-box reuse. On the other hand, with composition, the internals of the enclosing object are not visible to the enclosed object (and vice-versa); therefore, composition is often referred to as black-box reuse. All things being equal, black-box reuse (composition) is preferable to white-box reuse (inheritance) because loose coupling results in more malleable and flexible systems.

Because the Proxy pattern is so important, J2SE 1.3 (Java 2 Platform, Standard Edition) and beyond directly supports it. That support involves three classes from the java.lang.reflect package: Proxy, Method, and InvocationHandler.

Some basic concepts of Proxy class
> Proxy classes are public, final, and not abstract.
> The unqualified name of a proxy class is unspecified. The space of class names that begin with the string "$Proxy" should be, however, reserved for proxy classes.
> A proxy class extends java.lang.reflect.Proxy.
> A proxy class implements exactly the interfaces specified at its creation, in the same order.
> If a proxy class implements a non-public interface, then it will be defined in the same package as that interface. Otherwise, the package of a proxy class is also unspecified. Note that package sealing will not prevent a proxy class from being successfully defined in a particular package at runtime, and neither will classes already defined in the same class loader and the same package with particular signers.
> Since a proxy class implements all of the interfaces specified at its creation, invoking getInterfaces on its Class object will return an array containing the same list of interfaces (in the order specified at its creation), invoking getMethods on its Class object will return an array of Method objects that include all of the methods in those interfaces, and invoking getMethod will find methods in the proxy interfaces as would be expected.
> The Proxy.isProxyClass method will return true if it is passed a proxy class-- a class returned by Proxy.getProxyClass or the class of an object returned by Proxy.newProxyInstance-- and false otherwise.
> The java.security.ProtectionDomain of a proxy class is the same as that of system classes loaded by the bootstrap class loader, such as java.lang.Object, because the code for a proxy class is generated by trusted system code. This protection domain will typically be granted java.security.AllPermission.
> Each proxy class has one public constructor that takes one argument, an implementation of the interface InvocationHandler, to set the invocation handler for a proxy instance. Rather than having to use the reflection API to access the public constructor, a proxy instance can be also be created by calling the Proxy.newInstance method, which combines the actions of calling Proxy.getProxyClass with invoking the constructor with an invocation handler.
> A proxy instance has the following properties:
Given a proxy instance proxy and one of the interfaces implemented by its proxy class Foo, the following expression will return true:
proxy instanceof Foo
and the following cast operation will succeed (rather than throwing a ClassCastException):
(Foo) proxy
>Each proxy instance has an associated invocation handler, the one that was passed to its constructor. The static Proxy.getInvocationHandler method will return the invocation handler associated with the proxy instance passed as its argument.
>An interface method invocation on a proxy instance will be encoded and dispatched to the invocation handler's invoke method as described in the documentation for that method.
>An invocation of the hashCode, equals, or toString methods declared in java.lang.Object on a proxy instance will be encoded and dispatched to the invocation handler's invoke method in the same manner as interface method invocations are encoded and dispatched, as described above. The declaring class of the Method object passed to invoke will be java.lang.Object. Other public methods of a proxy instance inherited from java.lang.Object are not overridden by a proxy class, so invocations of those methods behave like they do for instances of java.lang.Object.


Below example shows a simple example that utilizes the JDK support for the Proxy pattern:

JDK proxies

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface AnInterface {
public void doSomething();
}

class AClass implements AnInterface {

public void doSomething() {
System.out.println("Inside Method AClass.doSomething()");
}
}
public class Test {

public static void main(String args[]) {
AnInterface realSubject = new AClass();
AnInterface proxy = (AnInterface)Proxy.newProxyInstance(
realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(),
new SimpleInvocationHandler(realSubject));

passMeAProxy(proxy);

}

private static void passMeAProxy(AnInterface anInterface) {
anInterface.doSomething();
}
}

class SimpleInvocationHandler implements InvocationHandler {

public SimpleInvocationHandler(Object realSubject) {
this.realSubject = realSubject;
}

public Object invoke(Object proxy, Method m, Object[] args){

Object result = null;
System.out.println("Before Calling " + m.getName());

try {
result = m.invoke(realSubject, args);
}

catch(Exception ex) {
System.exit(1);
}

System.out.println("After Calling " + m.getName());
return result;
}
private Object realSubject = null;
}


In the preceding example, the static Proxy.newProxyInstance() method creates a proxy for a real subject. Real subjects must implement one or more interfaces, and a reference to a proxy can be passed to any method that expects a reference to one of those interfaces. The main() method passes the proxy to a method that takes a reference to AnInterface, just to prove it can be done. In the preceding example, our simple proxy implements only one interface.

Proxy.newProxyInstance() takes three arguments: the class loader that loaded the real subject, a list of interfaces implemented by the real subject, and a reference to an invocation handler.

Every time you invoke a proxy's method, the proxy calls its invocation handler's invoke() method. The proxy passes itself to the invoke() method, along with a reference to the proxy's method and its list of arguments. In the preceding code, SimpleInvocationHandler.invoke() invokes the specified method on the real subject. Here's the output of the application listed in
Example

Before Calling doSomething
Inside Method AClass.doSomething()
After Calling doSomething

Proxy applicability
The Proxy pattern applies whenever you need to control access to an object. The most common situations include:

1.Remote proxies
2.Virtual proxies
3.Protection proxies - Security Authentication/Authorization

Remote proxies control access to remote objects, such as the Web service proxy.

Virtual proxies - control access to resources that are expensive to create, such as large images.

Protection proxies control what functionality specific users can access.

Classes that implement stable interfaces with few methods are the best candidates for a proxy's real subject because their proxies are easy to implement and maintain.TheJDK's built-in Proxy pattern support makes it much easier to implement proxies whose real subjects have a large number of methods.

Then whats the difference between the Decorator and Proxy patterns. Although you implement both patterns in an almost identical fashion, it's the intent of those patterns that differs. The Decorator pattern constructs objects at runtime by recursively enclosing an object within one or more decorators. The Proxy pattern acts as a stand-in for a real subject, which is set at compile time.

Dynamic Proxies with Spring

Dynamic proxies are extensively supported in Spring framework for following things

Spring AOP [Aspect Oriented Programming] - Interceptors - MethodInvocation is based on Dynamic Proxy
Spring Transaction Management [through TransactionProxyFactoryBean]


Easy Mock with Dynamic Proxy

Easy Mock - Creating mock objects for interfaces & classes for unit testing - creates mock objects using dynamic proxies


lot more .....

another custom example...

package org.nava.jfive.reflect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Calendar;

/**
* Client for testing
*/
public class Dec27 {

public static void main(String[] args) {

ITest realSubject = new TestImpl();

ITest proxy = (ITest)Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(),new TestHandler(realSubject));
proxy.setMe((proxy instanceof Proxy)?"is Proxy instance":"is not proxy instance");
System.out.println("The Result of 'me':"+proxy.getMe());
}

}

/**
* Inteface for Test
*/
interface ITest {
String getMe();
void setMe(String s);
}
/**
* Concreate Implementation for Inteface ITest
*/
class TestImpl implements ITest{

private String me_;

public String getMe() {
return me_;
}
public void setMe(String s) {
me_="The "+ s+" and the real object is :"+this.getClass().getSimpleName();
}
}

/**
* InvocationHandler for Test Proxy
*
*/
class TestHandler implements InvocationHandler{

private Object realSubject = null;

public TestHandler() {
super();
}
public TestHandler(Object real) {
this.realSubject=real;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("---------------------------------------------");
System.out.println("Is Proxy instance of TestImpl:"+(proxy instanceof TestImpl));
System.out.println("Is Proxy instance of ITest:"+(proxy instanceof ITest));
System.out.println("Is Proxy instance of Object:"+(proxy instanceof Object));
System.out.println("Is Proxy instance of Proxy:"+(proxy instanceof Proxy));
System.out.println(Calendar.getInstance().getTime()+" Before Calling " + method.getName());
try {
result = method.invoke(realSubject, args);
}catch(Exception ex) {
System.exit(1);
}
System.out.println(Calendar.getInstance().getTime()+"After Calling " + method.getName());
return result;
}

}