Java动态代理

           代理是基本的设计模式之一，它是为了提供额外的或不同的操作，而插入的用来代理"实际"对象的对象。这些操作通常涉及与”实际“对象的通信，因此代理通常充当着中间人的角色。下面的一个用例展示代理结构的简单示例。

　　接口:

/**
 * 接口
 * @author Arts&Crafts
 *
 */
public interface Interface {
    void doSomething();
    void somethingElse(String arg);
}

　　实际类:

/**
 * 实际类
 * @author Arts&Crafts
 *
 */
public class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("RealObject.doSomething()");
    }

    @Override
    public void somethingElse(String arg) {
        System.out.println("RealObject.somethingElse() " + arg);
    }

}

　　代理类:

/**
 * 代理类
 * 
 * @author Arts&Crafts
 * 
 */
public class SimpleProxy implements Interface {
    private Interface proxied;

    public SimpleProxy(Interface proxy) {
        this.proxied = proxy;
    }

    @Override
    public void doSomething() {
        System.out.println("SimpleProxy.doSomething()");
        proxied.doSomething();
    }

    @Override
    public void somethingElse(String arg) {
        System.out.println("SimpleProxy.somethingElse() " + arg);
        proxied.doSomething();
    }

}

　　测试:

public class SimpleProxyDemo {
public static void consumer(Interface iface){
    iface.doSomething();
    iface.somethingElse("Hello World");
}
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        consumer(new RealObject());
        System.out.println();
        consumer(new SimpleProxy(new RealObject()));
    }

}

　　因为consumer()接受的Interface，所以它无法知道正在获取的到底是RealObject还是SimpleProxy,因为这二者都实现了Interface。但是SimpleProxy已经被插入到客户端和RealObkect之间，因此它会执行操作，然后调用RealObject上相同的方法。

　　在任何时刻，只要你想要将额外的操作从“实际”对象中分离到不同的地方，特别是当你希望能够很容易地做出修改，从没有使用额外操作转换为使用这些操作，或者反过来，代理就显得很有用（设计模式的关键是封装修改——因此你需要修改事务以证明这种模式的正确性）。例如，如果你希望跟踪对RealObject中的方法的调用，或者希望度量这些调用的开销，那么你应该怎么样做呢？这些代码肯定是你不希望将其并到运用中的代码，因此代理使得你可以很容易地添加或移除它们。

　　Java的动态代理比代理的思想更向前迈进了一步，因为它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理上所在的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的对策。下面是用动态代理重写:

　　动态代理调用处理器类:

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

public class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    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);
        Object result = method.invoke(proxied, args);
        return result;
    }

}

     测试类:

import java.lang.reflect.Proxy;

import org.jdk.staticproxy.Interface;
import org.jdk.staticproxy.RealObject;

public class SimpleDynamicProxyDemo {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("Hello World");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        System.out.println();
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class[] { Interface.class }, new DynamicProxyHandler(real));
        consumer(proxy);
    }
}

　　通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器（你通常可以从已经被加载的对象中获取其类加载器，然后传递给它），一个你希望该代理实现的接口列表（不是类或抽象类），以及InvocationHandler接口的一个实现。动态代理可以将所有调用重定向到调用处理器，因此通常会向调用处理器的构造器传递给一个“实际”对象的引用，从而使得调用处理器在执行其中任务时，可以将请求转发。

　　invoke()方法中传递进来了代理对象，以放你需要区分请求的来源，但是在很多情况下，帮你并不关心这一点。然而，在invoke()内部，在代理上调用方法时需要格外当心，因为对接口的调用将被重定向为对代理的调用。