代理模式

本文讲述了代理模式，包括了普通代理、强制代理和动态代理。

原文链接：

http://tianweili.github.io/blog/2015/03/13/PRoxy-pattern/

代理模式属于结构性模式，使用频率很高。

定义：Provide a surrogate or placeholder for another object to control access to it.为其他对象提供一种代理以控制这个对象的访问。

装饰模式、状态模式、策略模式、访问者模式本质上都是在更特殊的场合采用了代理模式。

{% img /design-pattern/proxy-pattern-uml.png %}

从以上UML类图中可以看出代理模式主要有三种角色：

抽象主题角色

可以是接口或抽象类，是某类通用业务的定义。

具体主题角色

作为被代理对象，是具体业务的真实执行者。

代理主题角色

是具体主题对象的代理，负责对具体对象的应用，把所有抽象主题定义的方法委托给具体主题对象来实现，它用来在具体主题对象业务处理的前后做一些处理工作。

/** * Abstract subject class. */public interface Subject {    public void someMethod();}/** * Real subject class. */public class RealSubject implements Subject {    private String name;    public RealSubject(String name) {        this.name = name;    }    @Override    public void someMethod() {        System.out.println(name + "'s someMehtod.");    }}/** * Proxy class. */public class ProxySubject implements Subject {    private Subject subject;    public ProxySubject(Subject subject) {        this.subject = subject;    }    @Override    public void someMethod() {        this.before();        subject.someMethod();        this.after();    }    /**     * preprocessing     */    private void before() {        // do something...    }        /**     * follow-up processing     */    private void after() {        // do something...    }}

从以上代码可以看出ProxySubject对象还有before和after方法，可以在RealSubject对象的someMethod业务方法前后做一些预处理和善后处理工作。

一个代理类可以代理多个被代理对象，只要是实现同一个接口。当然也可以一个被代理对象就有一个代理类，不过一般是一个接口有一个代理类就够了，在应用时具体是代理哪一个被代理对象，这是由场景类也就是高层模块定义的，根据构造方法的传入哪一个被代理对象参数来决定代理哪一个对象。

构造方法：

public ProxySubject(Subject subject) {    this.subject = subject;}

想代理哪个对象就要传入生成这个对象的实例。

各个角色职责清晰，比如被代理对象只需要实现属于自己具体的业务逻辑就行了，不用去关心非本职责的业务处理。其他的一些处理业务可以交给代理类来处理。这样做的好处是编程简洁清晰，业务分明。

扩展性好，具体实现对象的业务发生了变化，只需要修改自身业务处理逻辑，或者增加删减一个实现业务接口的对象，不会影响代理业务。

代理模式可以提供非常好的访问控制，由代理类来控制被代理对象，可以做一些预处理消息，过滤消息，消息转发和善后处理工作等等。

普通代理和强制代理是代理模式的两种不同结构，是根据调用者能够访问到代理对象还是具体对象来区分的。就好比网络上的代理服务器设置分为普通代理和透明代理。普通代理需要用户手动设置代理服务器的ip地址，用户必须知道代理的存在。透明代理就是用户不需要设置代理服务器地址，就可以直接访问，不用知道代理的存在。

普通代理是用户只能访问代理角色，而不能访问真实角色。

只需要对上面代码稍作改动即可实现普通代理的效果，代码如下：

/** * Abstract subject class. */public interface Subject {    public void someMethod();}/** * Real subject class. */public class RealSubject implements Subject {    private String name;    /**     * Don't allow client call this.     */    public RealSubject(Subject subject, String name) throws Exception {        if(subject == null) {            throw new Exception("Don't allow realSubject created!");        } else {            this.name = name;        }    }    @Override    public void someMethod() {        System.out.println(name + "'s someMehtod.");    }}/** * Proxy class. */public class ProxySubject implements Subject {    private Subject subject;    /**     * Client call proxy subject.     */    public ProxySubject(String name) {        try {            this.subject = new RealSubject(this, name);        } catch (Exception e) {            e.printStackTrace();        }    }    @Override    public void someMethod() {        this.before();        subject.someMethod();        this.after();    }    /**     * preprocessing     */    private void before() {        // do something...        System.out.println("before ...");    }        /**     * follow-up processing     */    private void after() {        // do something...        System.out.println("after ...");    }}public class Client {    public static void main(String[] args) {        Subject subject = new ProxySubject("ZhangSan");        subject.someMethod();    }}

运行程序结果如下：

before ...ZhangSan's someMehtod.after ...

在上面RealSubject的构造方法中是通过传入参数subject来限制用户不能实例化自己，当然也可以通过别的一些限制条件，比如类名必须有Proxy等等。

普通代理是通过代理角色找到真是角色，而强制代理是强制只能通过真实角色查找代理角色来访问，想直接通过实例化代理角色或真实角色都不能访问。

UML类图如下：

{% img /design-pattern/proxy-pattern-uml-2.png %}

从以上UML类图可以看出Subject接口中添加了个获取代理的接口方法。

代码清单：

/** * Abstract subject class. */public interface Subject {    public void someMethod();    public Subject getProxy();}/** * Real subject class. */public class RealSubject implements Subject {    private String name;    private Subject proxy;    public RealSubject(String name) {        this.name = name;    }    @Override    public void someMethod() {        if (this.isProxy()) {            System.out.println(name + "'s someMehtod.");        } else {            System.out.println("Only visit proxy class is allowed!");        }    }    @Override    public Subject getProxy() {        // appoint proxy class.        this.proxy = new ProxySubject(this);        return proxy;    }    private boolean isProxy() {        if (this.proxy == null) {            return false;        } else {            return true;        }    }}/** * Proxy class. */public class ProxySubject implements Subject {    private Subject subject;    public ProxySubject(Subject subject) {        this.subject = subject;    }    @Override    public void someMethod() {        subject.someMethod();    }    @Override    public Subject getProxy() {        return this;    }}

当客户端想通过真实角色来访问时，客户端代码如下：

public class Client {    public static void main(String[] args) {        Subject realSubject = new RealSubject("ZhangSan");        realSubject.someMethod();    }}

执行结果：

Only visit proxy class is allowed!

访问被拒绝，因为它是通过真实角色来直接访问的，而不是通过真实角色来获取代理角色来访问。

当客户端想通过代理角色来访问时，客户端代码如下：

public class Client {    public static void main(String[] args) {        Subject realSubject = new RealSubject("ZhangSan");        Subject proxy = new ProxySubject(realSubject);        proxy.someMethod();    }}

执行结果：

Only visit proxy class is allowed!

访问同样被拒绝，因为它是通过代理角色来直接访问的，而不是通过真实角色来获取代理角色来访问。

只有强制客户端通过真实角色来获取代理对象，才能访问。客户端代码如下：

public class Client {    public static void main(String[] args) {        Subject realSubject = new RealSubject("ZhangSan");        Subject proxy = realSubject.getProxy();        proxy.someMethod();    }}

执行结果：

ZhangSan's someMehtod.

通过真实角色来获取代理对象访问成功。

这一节之前所讲的代理其实都是静态代理，它有一个特点就是要在实现阶段就要指定代理类以及被代理者，很不灵活。而动态代理就是在实现阶段不用管代理具体对象，而在运行阶段指定代理哪个对象即可生产代理对象。

基本的UML类图如下所示：

{% img /design-pattern/proxy-pattern-uml-3.png %}

从类图中可以看出，具体的业务逻辑和代理逻辑是两条线，两者之间没有必然的耦合关系。

InvocationHandler是JDK提供的接口，用来对被代理类的方法进行代理。

注意：被代理者必须实现一个接口，否则动态代理无法生成代理对象。

动态代理是根据被代理者的接口生成所有的方法。通过InvocationHandler接口，所有被代理的方法都由InvocationHandler来接管实际的处理逻辑。

代码清单：

/** * Abstract subject class. */public interface Subject {    public void someMethod();}/** * Real subject class. */public class RealSubject implements Subject {    private String name;    public RealSubject(String name) {        this.name = name;    }    @Override    public void someMethod() {        System.out.println(name + "'s someMehtod.");    }}import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class MyInvocationHandler implements InvocationHandler {    private Object obj;    public MyInvocationHandler(Object obj) {        this.obj = obj;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("before...");        Object result = method.invoke(obj, args);        System.out.println("after...");        return result;    }}

invoke方法是接口InvocationHandler中定义必须实现的，它用来完成对真实方法的调用。

客户端调用代码：

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;public class Client {    public static void main(String[] args) {        Subject subject = new RealSubject("ZhangSan");                ClassLoader loader = subject.getClass().getClassLoader();        Class[] interfaces = subject.getClass().getInterfaces();        InvocationHandler handler = new MyInvocationHandler(subject);                Subject proxy = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);        proxy.someMethod();    }}

执行结果：

before...ZhangSan's someMehtod.after...

从结果中可以看出我们已经达到了代理RealSubject对象的目的。

看了上面的客户端调用代码，我们可以优化一下，将Proxy封装起来，使得调用更简便一些。增加动态代理封装类：

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;public class DynamicProxy {        public static Object newProxyInstance(Object object) {                ClassLoader loader = object.getClass().getClassLoader();        Class[] interfaces = object.getClass().getInterfaces();        InvocationHandler handler = new MyInvocationHandler(object);                return Proxy.newProxyInstance(loader, interfaces, handler);    }}

客户端调用：

public class Client {    public static void main(String[] args) {        Subject subject = new RealSubject("ZhangSan");        Subject proxy = (Subject) DynamicProxy.newProxyInstance(subject);        proxy.someMethod();    }}

动态代理拥有以上静态代理所有优点，除此之外还有动态代理的代理对象是在需要的时候动态生成的。

在业务逻辑开发时可以不用管代理业务逻辑，这两条线不会耦合。比如在做具体的业务逻辑设计和实现时不用考虑日志、事务、权限等逻辑处理，这些可以通过动态代理来搞定。

Struts2的Form映射和Spring的AOP（aspect Oriented Programming）就是动态代理的典型应用。

作者：李天炜

原文链接：http://tianweili.github.io/blog/2015/03/13/proxy-pattern/

转载请注明作者和文章出处，谢谢。