代理模式，以及Java的动态代理

定义

为其他对象提供一种代理以控制对这个对象的访问。可以提供额外不同的操作。

UML类图

Subject类：定义了RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy

RealSubject类：真是实体

Proxy类：代理类，保存一个引用使得代理可以访问实体，并提供一个与Subject接口相同的接口，这样代理就可以用来替代实体。

简单的代码类如下：

public abstract class Subject {
    public abstract void Request();
}

public class RealSubject extends Subject {
    @Override public void Request() {
        System.out.println("真实请求");
    }
}

public class Proxy extends Subject {
    private RealSubject realObject = new RealSubject();
    @Override public void Request() {
        System.out.println("代理的请求");
        realObject.Request();
    }
}

public class Client {
    public static void main(String[] args) {
        Subject proxy = new Proxy();
        proxy.Request();
    }
}

示例

举个栗子，大学的时候经常在宿舍里不想出去，有时候让室友帮忙在食堂里带饭。

我：在宿舍不想出去

室友：帮我带饭

public abstract class Subject {
    public abstract void buyLaunch();
}

public class RealSubject extends Subject {
    @Override public void buyLaunch() {
        System.out.println("我要买午饭");
    }
}

public class Proxy extends Subject {
    private RealSubject realObject = new RealSubject();

    @Override public void buyLaunch() {
        System.out.println("室友帮我买午饭");
        wrapLaunch();
        realObject.buyLaunch();
    }

    private void wrapLaunch() {
        System.out.println("打包带走");
    }
}

代理模式其实就是这么简单~~~

Java的动态代理

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

先来看一下动态代理的例子：

public interface ObjectInterface {
    void doSomething();

    void somethingElse(String arg);
}

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

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

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);
            }
        }
        return method.invoke(proxied, args);
    }
}

public class SimpleDynamicProxy {

    public static void consumer(ObjectInterface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

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

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

看一下SimpleDynamicProxy运行的输入内容：

在consumer方法中，调用ObjectInterface的任何方法，都会先经过DynamicProxyHandler的invoke方法中转，实现统一处理的功能。