设计模式之：代理模式

前言

在平时的开发过程中，常看到代理模式身影，下面是通过阅读《设计模式之禅（第二版）》的代理模式章节后的读后感。

正题

代理模式（Proxy Pattern）是一个使用率非常高的模式，其定义如下：

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

代理模式的通用类如下图：

代理模式也叫做委托模式，它是一项基本设计模式。在日常的应用中，代理模式可以提供非常好的访问控制。在一些著名开源软件中也经常见到它的身影，如 Struct2 的 Form 元素映射就采用了代理模式（准确的说是动态代理模式）。我们先看一下类图中的三个角色的定义。

• Subject 抽象主题角色：抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。
  

• RealSubject 具体主题角色：也叫做被委托角色，被代理角色。它才是冤大头，是业务逻辑的具体执行者。
  

• Proxy 代理主题角色：也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。
  

我们首先来看 Subject 抽象主题类的通用源码：

public interface Subject {
    //定义一个方法
    public void request();
}

在接口中我们定义了一个方法request来作为方法的代表，RealSubject对它进行实现：

public class RealSubject implements Subject{
    public void request() {
        //业务逻辑处理
    }
}

RealSubject是一个正常的业务实现类，代码模式的核心就在代理类上：

public class Proxy implements Subject{
    //要代理哪个实现类
    private Subject subject = null;

    //默认被代理者
    public Proxy() {
        this.subject = new Proxy();
    }

    //通过构造函数传递代理者
    public Proxy(Object... objects) {
    }
    
    //实现接口中定义的方法
    public void request() {
        this.befroe();
        this.subject.request();
        this.after();
    }

    //预处理
    private void befroe() {
        //do something
    }

    //善后处理
    private void after() {
        //do something
    }
}

看到这里，大家被惊讶，为什么会出现 before 和 after 方法，继续看下去，这是一个“引子”，能够引出一个崭新的编程模式。

一个代理类可以代理多个被委托者或被代理者，因此一个代理类具体代理哪个真实主题角色，是由场景类决定的。当然，最简单的情况就是一个主题类和一个代理类，这是最简单的代理模式。在通常情况下，一个接口只需要一个代理类就可以了，具体代理哪个实现类由高层模块来决定，也就是在代理类的构造函数中传递被代理者，例如我们可以在代理类Proxy中增加如下代码的构造函数：

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

你要代理谁就产生该代理的实例，然后把被代理者传递进来，该模式在实际的项目应用中比较广泛。

代理模式的优点

• 职责清晰
• 真实的角色就是实现实际的业务逻辑，不用关心其他非本职的事务，通过后期的代理完成一件事务，附带的结果就是编程简洁清晰。
• 高扩展性
  • 具体主题角色是随时都会发生变化的，只要它实现了接口，甭管它如何变化，都逃不脱如来佛的手掌（接口），那我们的代理类完全就可以在不做任何修改的情况下使用。
• 智能化
  • 这在我们以上的讲解中还没有提现出来，不过在我们一下的动态代理中你就会看到代理的智能化。
    

代理模式的使用场景

为什么要用代理？想想现实世界，打官司为什么要找个律师？因为你不想参与中间过程的是是非非，只要完成自己的答辩就成，其他的比如事前调查、时候追查都由律师来搞定，这就是为了减轻你的负担。代理模式的使用场景非常多，大家可以看看Spring AOP，这是一个非常典型的动态代理。

普通代理

它的要求就是客户端只能访问代理角色，而不能访问真实角色，这是比较简单的。

GamePlayer代码清单如下：

public class GamePalyer implements IGamePlayer{
    private String name;
    
    //构造函数限制谁能创建对象，并同时创建姓名
    public GamePalyer(IGamePlayer gamePlayer, String name) throws Exception{
        if(gamePlayer == null) {
            throw new Exception("不能创建真实角色");
        } else {
            this.name = name;
        }
    }

    //登录
    public void login(String user, String name) {
    }

    //杀怪
    public void killBoss() {
    }

    //升级
    public void upgrade() {
    }
}

在构造函数中，传递进来一个 IGameplayer 对象，检查谁能创建真实的角色，当然还可以有其他的限制，比如类名必须为 Proxy 类等，可以根据实际情况进行扩展。

普通代理的代理者代码如下：

public class GamePlayerProxy implements IGamePlayer{
    private IGamePlayer gamePlayer = null;

    public GamePlayerProxy(String name) {
        try {
            gamePlayer = new GamePalyer(this, name);
        } catch (Exception e) {
        }
    }

    //代练登录
    public void login(String user, String name) {
        this.gamePlayer.login(user, name);
    }

    //代练杀怪
    public void killBoss() {
        this.gamePlayer.killBoss();
    }

    //代练升级
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
}

构造函数只传递进来一个代理者名称，即可进行代理。调用者只知道代理存在就可以，不用知道代理了谁。

public class Client {
    public static void main(String[] args) {
        //定义一个代练者
        IGamePlayer proxy = new GamePlayerProxy("张三");
        //登录
        proxy.login("zhangsan", "password");
        //杀怪
        proxy.killBoss();
        //升级
        proxy.upgrade();
    }
}

在该模式下，调用者只知代理而不用知道真实的角色是谁，屏蔽了真实角色的变更对高层模块的影响，真实的主题角色想怎么修改就怎么修改，对高层次的模块没有任何的影响，只要你实现了接口所对应的方法，该模式非常适合对扩展性要求较高的场合。当然，在实际的项目中，一般都是通过约定来禁止new一个真实的角色，这也是一个非常好的方案。

动态代理

动态代理是在实现阶段不用关心代理谁，而在运行阶段指定代理哪一个对象。相对来说，自己写代理类的方式就是静态代理。现在有一个非常流行的名称叫做面向横切面编程，也就是AOP（Aspect Oriented Programming），其核心就是采用了动态代理机制，既然这么重要，接下来看看动态代理的实现方式。

在类图中增加了一个InvocationHandler接口和GamePlayIHI类，作用就是产生一个对象的代理对象，其中InvocationHandler是JDK提供的动态代理接口，对被代理类的方法进行代理。

public class GamePlayIH implements InvocationHandler{
    //被代理者
    Class clazz = null;
    //被代理的实例
    Object obj = null;

    //要代理谁
    public GamePlayIH(Object obj) {
        this.obj = obj;
    }

    //调用被代理的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.obj, args);
        return result;
    }
}

其中invoke方法是接口 InvocationHandler 定义必须实现的，它完成对真实方法的调用。接下来详细讲解一下 InvocationHandler 接口，动态代理是根据被代理的接口生成所有的方法，也就是说给定一个接口，动态代理会宣称“我已经实现了该接口下的所有方法了”，那动态代理怎么才能实现被代理接口中的方法呢？默认情况下所有的方法的返回值都是空的，是的，代理已经实现它了，但是没有任何的逻辑定义，那怎么办？好办，通过 InvocationHandler 接口，所有方法都由该 Handler 来进行处理，即所有被代理的方法都由 InvocationHandler 接管实际的处理任务。

public class Client {
    public static void main(String[] args) {
        //定义一个玩家
        IGamePlayer player = new GamePalyer("张三");
        //定义一个handler
        InvocationHandler handler = new GamePlayIH(player);
        //获取类的class loader
        ClassLoader classLoader = player.getClass().getClassLoader();
        //动态生成一个代理
        IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(classLoader,player.getClass().getInterfaces(),handler);
        proxy.login("张三","password");
        proxy.killBoss();
        proxy.upgrade();
    }
}

我们既没有创建代理类，也没有实现 IGamePlayer 接口，这就是动态的代理。接下来看看通用代理模型，类图如下：

很简单，两条独立发展的线路。动态代理实现代理的职责，业务逻辑 Subject 实现相关的逻辑功能，两者之间没有必然的相关耦合的关系。通知 Advice 从另一个切面切入，最终在高层模块也就是 Client 进行耦合，完成逻辑的封装任务。

先来看 Subject 接口：

public interface Subject {
    //业务操作
    void doSomething(String str);
}

其中 doSomething 是一种标识方法，可以有多个逻辑处理方法，实现类代码如下：

public class RealSubject implements Subject{

    //业务操作
    public void doSomething(String str) {
        System.out.println("doSomething ---->" + str);
    }
}

重点是MyInvocationHandler，代码如下：

public class MyInvocationHandler implements InvocationHandler{
    //被代理的实例
    Object obj = null;

    //要代理谁
    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    //调用被代理的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(this.obj, args);
    }
}

所有通过动态代理实现的方法全部通过invoke方法调用。接下来看看动态代理类的实现：

public class DynamicProxy<T> {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
        if(true) {
            //执行一个前置通知
            new BeforeAdvice().exce();
        }
        //执行目标并返回结果
        return (T) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

在这里插入了较多的AOP术语，如在什么地方（连接点）执行什么行为（通知）。在这里实现了一个简单的横切面编程。紧接着看通知Advice，也即是要切入的类：

public interface IAdvice {
    void exce();
}

public class BeforeAdvice implements IAdvice {
    public void exce() {
        System.out.println("前置通知");
    }
}

最后看看怎么调用：

public class Client {
    public static void main(String[] args) {
        //定义一个主题
        Subject subject = new RealSubject();
        //定义一个handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        //定义主题的代理
        Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(),handler);
        proxy.doSomething("Finish");
    }
}

运行结果：

前置通知
doSomething ---->Finish

好，所有的程序都看完了，现在回过头来看看程序是怎么实现的。在DynamicProxy类中，有这样的方法：

Proxy.newProxyInstance(c.getClassLoader(), c.getInterfaces(), new MyInvocationHandler(obj));

该方法是重新生成一个对象，为什么要重新生成？你要使用代理呀，注意c.getInterfaces()这句话，这是非常有意思的一句话，是说查找到该类的所有接口，然后实现接口的所有方法。当然了，方法都是空的，由谁具体负责接管呢？是new MyInvocationHandler(obj)这个对象。于是我们知道一个类的动态代理类是这样的一个类，由InvocationHandler的实现类实现所有的方法，由其invoke方法接管所有方法的实现。

对以上的代码还有更进一步的扩展余地，注意看DynamicProxy类，它是一个通用类，不具有业务意义，如果再生成一个实现类是不是就很有意义呢？如下代码：

public class SubjectDynamicProxy extends DynamicProxy{
    public static <T> T newProxyInstance(Subject subject) {
        //获取ClassLoader对象
        ClassLoader loader = subject.getClass().getClassLoader();
        //获取接口数组
        Class[] interfaces = subject.getClass().getInterfaces();
        //生成Handler对象
        InvocationHandler h = new MyInvocationHandler(subject);
        //执行目标并返回结果
        return (T) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

如此扩展以后，高层模块对代理的访问会更加简单，如下代码：

public class Client {
    public static void main(String[] args) {
        //定义一个主题
        Subject subject = new RealSubject();
        //定义一个代理对象
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        proxy.doSomething("Finish");
}

是不是更加简单了？可能会产生疑问：这样与静态代理还有什么区别？都是需要实现一个代理类，有区别，注意看父类，动态代理的主要意图就是解决我们常说的“审计”问题，也就是横切面编程，在不改变我们已有代码结构的情况下增强或控制对象的行为。

这样的实现与静态代理有什么区别？都是需要实现一个代理类，有区别，注意看父类，动态代理的主要意图就是解决我们常说的“审计”问题，也就是横切面编程，在不改变我们已有代码结构的情况下增强或控制对象的行为。

注意要实现动态代理的首要条件是：被代理类必须实现一个接口。