代理模式简介

代理模式是设计模式中非常常用的一种设计模式，在Java和安卓源码中都有涉及。使用代理模式可以对一些事务进行日志处理，权限控制等。

为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介作用，可去掉功能服务或增加额外的服务。

代理模式的几种实现方式

代理模式一般有三种：

使用继承
使用聚合
动态代理(重点)
继承和聚合的方式相对于动态代理来说可以认为是静态代理，因为这两种方式的代理类是静态实现的，而动态代理类是根据参数的不同动态实现的。

代理的实现

继承实现代理

使用继承的方式实现代，理非常简单。其实原理就是子类继承父类，子类是父类的代理。

构建以下场景：

比如我们有一公共汽车Bus,在汽车启动前需要确认司机身份，司机身份确认后才能开始行驶，并记录汽车行驶时间，那么我们该如何构建类的关系呢？如果再有一辆小轿车也要做相同的事情呢？如果再有火车，马车。。。

最简单的方法就是：定义一个汽车类Bus.java，它有一个move方法，在move调用前进行身份验证，记录时间这些工作。再定义一个轿车类Car.java,它有一个move方法，在move方法调用前进行身份验证，记录这些工作。再定义。。。很明显，我们这样会使代码无限增多，维护性差，扩展性差。那么我们就定义一个接口Moveable.java，所有类型的车的类都要实现这个接口。

Moveable.java

public interface Moveable {
    void move();
}

Bus.java

public class Bus implements Moveable {
    @Override
    public void move() {
        //预处理逻辑
        System.out.println("确认司机身份中...");
        System.out.println("启动...");
        long startTime = System.currentTimeMillis();
        //核心逻辑
        System.out.println("moving");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("车辆行驶时间:" + (endTime - startTime) + "毫秒");
    }
}

我们实现了一Bus.java类，但足以说明问题了。

可以发现，此时我们的身份验证和时间记录是写死在move方法中的，很明显这是内聚过度，导致了move的核心逻辑和预处理(身份验证)耦合性太强。

这时我们需要把身份验证和move的核心逻辑进行解耦，新建一个代理类ExtendsProxy.java

public class ExtendsProxy extends Bus {
    @Override
    public void move() {
        //预处理逻辑
        System.out.println("确认司机身份中...");
        System.out.println("启动...");
        long startTime = System.currentTimeMillis();
        super.move();//调用被 代理对象的方法
        long endTime = System.currentTimeMillis();
        System.out.println("车辆行驶时间:" + (endTime - startTime) + "毫秒");
    }
}

这时在Bus.java的move方法中就不需要做预处理操作了，Bus.java如下：

public class Bus implements Moveable {
    @Override
    public void move() {
        System.out.println("moving");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

我们来测试一下：

public class Client {
    public static void main(String[] args) {        
        //新建代理类对象
        Moveable m = new ExtendsProxy();
        //调用代理方法
        m.move();       
    }
}

结果如下：

确认司机身份中...
启动...
moving
车辆行驶时间:175毫秒

非常好！很开心我们实现了一个代理。可是突然又增加了需求，我们不仅要代理Bus了，还要代理小轿车Car，那怎么办呢？有的人说：好办，再新建一个类继承Car.java，用同样的方式实现代理不就可以了吗？这样确实是可以的，但是相信你的leader会不开森，要是代理一百个类，那你还再写一百个代理类么？这时你突然醒悟过来：继承的方式实现代理有很大的局限性，扩展性不好，那么我们是坚决摒弃这种做法的。

聚合实现代理

聚合方式是通过把被代理对象当作参数传入代理对象中。这种方式是很常用的方式。

我们实现UnionProxy.java，它也需要实现Moveable接口。为什么要实现Moveable接口呢？统一接口，统一调用。

public class UnionProxy implements Moveable {
    private Moveable m;
    public UnionProxy(Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        if (m != null) {
            //预处理逻辑
            System.out.println("确认司机身份中...");
            System.out.println("启动...");
            long startTime = System.currentTimeMillis();
            //调用被 代理对象的方法
            m.move();
            long endTime = System.currentTimeMillis();
            System.out.println("车辆行驶时间:" + (endTime - startTime) + "毫秒");
        }
    }
}

这时如果我们再想要代理其实实现了Movealbe的类，比如轿车，马车之类的，那么我们做的是直接把它们的对象传到UnionProxy的构造参数中即可，解决了继承方式的弊端，真棒！

但是，但是，但是，问题又来了，现在Leader要求，先启动汽车，再确认身份，顺序颠倒了，那么怎么办呢。因为我们的预处理逻辑是硬编码的，要想添加新的逻辑，那么只能再写一个UnionProxy2.java，在move方法中重新定义预处理逻辑，这样好不好呢？没错，正如你所想的那样，肯定是不好的，因为如果我们有一万种预处理逻辑，就要再写一万个代理类吗？我们希望有一种代理类，既可以动态得传入被代理对象，又可以动态得生成代理方法，这就是动态代理！

动态代理

动态代理在JDK中提供了API，我们可以很方便得使用它，下面我们来了解一下动态代理是如何使用的吧。

JDK中在java.long.reflect中提供了两个类：

Proxy.java 代理类，用来生成代理对象
InvocationHandler.java 实现这个接口，添加预处理逻辑等
使用流程如下：

新建xxxHandler实现InvocationHandler接口，添加预处理逻辑
创建被代理类对象，并获取被代理类对象的ClassLoader和Intefaces
创建xxxHandler对象
调用Proxy.newInstance(loader, interfaces, handler);来创建代理类对象
调用代理类对象的代理方法
我们这里创建DDdogerHandler.java实现InvocationHandler接口
DDdogerHandler.java

public class DDdogerHandler implements InvocationHandler {
    //被代理对象
    private Object target;  
    public DDdogerHandler(Object target) {
        super();
        this.target = target;
    }
    /**
     * o  被代理对象
     * m  被代理的方法
     * args 被代理方法的参数
     */
    @Override
    public Object invoke(Object o, Method m, Object[] args) throws Throwable {
        // 预处理逻辑
        System.out.println("确认司机身份中...");
        System.out.println("启动...");
        long startTime = System.currentTimeMillis();
        m.invoke(target);//调用被代理方法，并传入被代理对象作为参数
        long endTime = System.currentTimeMillis();
        System.out.println("车辆行驶时间:" + (endTime - startTime) + "毫秒");
        return null;
    }
}

接下来创建代理对象并调用：

public static void main(String[] args) {
        Moveable target;
        // 新建被代理对象
        target = new Bus();
//      target = new Car();
        // 新建handler对象
        DDdogerHandler handler = new DDdogerHandler(target);
        /**
         * 参数： loader 类加载器 
         * interfaces 被代理对象实现的接口 
         * h InvocationHandler对象
         */
        Moveable m = (Moveable) Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(),
                handler);
        m.move();
    }

运行结果如下：

确认司机身份中...
启动...
The bus is moving
车辆行驶时间:72毫秒

我们先来分析一下，如何使用JDK提供的API实现对任意对象添加任意的代理

正如之前所说：如果我们要对其它类比如Car.java实现先验证司机身份再启动的，最后记录行驶时间的代理，那我们应该怎么做呢？

因为代理的预处理工作不变，所以只需要把传入把Bus对象换成Car对象即可，如下：

public static void main(String[] args) {
        Moveable target;
        // 新建被代理对象
//      target = new Bus();
        target = new Car();
        // 新建handler对象
        DDdogerHandler handler = new DDdogerHandler(target);
        /**
         * 参数： loader 类加载器 
         * interfaces 被代理对象实现的接口 
         * h InvocationHandler对象
         */
        Moveable m = (Moveable) Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(),
                handler);
        m.move();
    }

运行结果如下：

确认司机身份中...
启动...
The car is moving
车辆行驶时间:770毫秒

怎么样，很简单吧。那么我们如果想要实现先启动，再验证司机身份的预处理逻辑该怎么做呢？那我们只需要把参数传入到handler对象中，根据参数来定义预处理逻辑的顺序即可。这里不再详述。

看来动态代理确实很方便啊，那它内部究竟是如何实现的呢？

下面我们来手动实现动态代理吧~

手动实现动态代理

动态代理，顾名思义，就是动态得生成代理类，再动态得把代理类编译成class文件，最后生成代理类对象并调用的一个过程。所以我们的实现思路如下：

首先要声明一段源码，要知道源码其实就是一些字符,把这些字符写到文件中就是源码文件了
编译源码，JDK提供了相关的Complier API，生成字节码文件
通过反射通过字节码文件生成代理对象
PS:为了与JDK的API区别开来，以下类使用不同的命名方式。
首先要有一个代理类DDdogerProxy.java，它有一个方法newInstance()来生成代理类对象。生成对象的过程就是上面的3步。
话不多说，先上源码！

public class DDdogerProxy {
    /**
     * @param infc 被代理类实现的接口Class对象
     * @return
     * @throws Exception
     */
    public static Object newInstance(Class infc) throws Exception {
        //1 生成源码文件
        //1.1 声明一段源码，这里使用的是UnionProxy的源码进行稍加整理
        //其中Moveable需要根据传入的参数infc来确定
        //构建的代理类名取为$Proxy0，与jdk保持一致，当然也可以换成别的名字
        String sourceStr = "package com.dddoger.proxy;\r\n" + 
                "\r\n" + 
                "public class $Proxy0 implements "+ infc.getName() +" {\r\n" + 
                "   private "+ infc.getName() +" m;\r\n" + 
                "   public $Proxy0("+ infc.getName() +" m) {\r\n" + 
                "       this.m = m;\r\n" + 
                "   }\r\n" + 
                "   @Override\r\n" + 
                "   public void move() {\r\n" + 
                "       if (m != null) {\r\n" + 
                "           //预处理逻辑\r\n" + 
                "           System.out.println(\"确认司机身份中...\");\r\n" + 
                "           System.out.println(\"启动...\");\r\n" + 
                "           long startTime = System.currentTimeMillis();\r\n" + 
                "           \r\n" + 
                "           //调用被 代理对象的方法\r\n" + 
                "           m.move();\r\n" + 
                "           \r\n" + 
                "           long endTime = System.currentTimeMillis();\r\n" + 
                "           System.out.println(\"车辆行驶时间:\" + (endTime - startTime) + \"毫秒\");\r\n" + 
                "       }\r\n" + 
                "   }\r\n" + 
                "}";
        //1.2 定义文件名，相对路径，位于工程目录下/bin/com/dddoger/proxy/$Proxy0.java
        String filename = System.getProperty("user.dir") +"/bin/com/dddoger/proxy/$Proxy0.java";
        File file = new File(filename);
        //1.3 这里使用的commons-io方便操作，生成源文件$Proxy0.java
        FileUtils.writeStringToFile(file, sourceStr);
        //2 编译源码文件
        //2.1 获取系统编译器
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        //2.2 通过cmopiler对象获取文件管理者对象
        StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
        //2.3 获取文件对象
        Iterable fileObjs = fileMgr.getJavaFileObjects(filename);
        //2.4 建立编译任务
        CompilationTask task = compiler.getTask(null, fileMgr, null, null, null, fileObjs);
        //2.5 开始编译任务
        task.call();
        //3 加载class文件到内存
        //3.1 获取类加载器
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        //3.2 加载指定的类到内存，我们只需要加载代理类$Proxy
        Class clazz = loader.loadClass("com.dddoger.proxy.$Proxy0");
        //4 使用构造器创建代理对象并返回
        //4.1 获取被代理类的构造器，参数为被代理类对象
        Constructor constructor = clazz.getConstructor(infc);
        //4.2 创建代理对象，并传入参数
        Object proxy = constructor.newInstance(new Bus());
        return proxy;
    }
}

注释已经写得很详细了，相信大家理解整体的思路。

然后来测试一下看：

public static void main(String[] args) throws Exception {
        Moveable target;
        //被代理对象
        target = new Bus();
        //生成代理对象，因为代理类是实现了Movealbe接口的，
        //也就是说代理类和被代理类都实现了同一接口
        Moveable m = (Moveable)DDdogerProxy.newInstance(Moveable.class);
        m.move();
    }

运行结果：

确认司机身份中...
启动...
The Bus is moving
车辆行驶时间:533毫秒

再说明一下中间过程，这样更清晰一些。

在执行完FileUtils.writeStringToFile(file, sourceStr);之后，会生成源码文件$Proxy0.java，使用Navigator可以看到：

$Proxy0.java内容如下:

package com.dddoger.proxy;
public class $Proxy0 implements com.dddoger.proxy.Moveable {
    private com.dddoger.proxy.Moveable m;
    public $Proxy0(com.dddoger.proxy.Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        if (m != null) {
            //预处理逻辑
            System.out.println("确认司机身份中...");
            System.out.println("启动...");
            long startTime = System.currentTimeMillis();
            //调用被 代理对象的方法
            m.move();
            long endTime = System.currentTimeMillis();
            System.out.println("车辆行驶时间:" + (endTime - startTime) + "毫秒");
        }
    }
}

经过执行task.call();后会生成$Proxy0.class

字节码文件，需要先加载到内存中，再创建对象。

写到这里，动态代理还没有完全实现，因为我位的代理逻辑是硬编码的，需要把这些代理逻辑解耦，该怎么办呢？别忘了，JDK中有一个InvocationHandler的类，叫做事务处理器，代理逻辑是放在这里面的。把InvocationHandler对象传到DDdogerProxy作为参数，再反射调用InvocationHandler的方法不就可以了吗。

DDdogerInvocationHandler.java

public interface DDdogerInvocationHandler {
    /**
     * @param proxy 代理对象
     * @param m 被代理方法
     * @throws Exception 
     */
    void invoke(Object proxy, Method m) throws Exception;
}

实现该接口，并添加代理逻辑

BusHandler.java

public class BusHandler implements DDdogerInvocationHandler {
    private Object target;  
    public BusHandler(Object target) {
        super();
        this.target = target;
    }   
    @Override
    public void invoke(Object proxy, Method m) throws Exception {
        // 预处理逻辑
        System.out.println("确认司机身份中...");
        System.out.println("启动...");
        long startTime = System.currentTimeMillis();
        m.invoke(target);
        long endTime = System.currentTimeMillis();
        System.out.println("车辆行驶时间:" + (endTime - startTime) + "毫秒");
    }
}

我们的代理类DDdogerProxy.java也要做一些修改，添加handler参数，并且动态得生成代理逻辑。

修改后的DDdogerProxy.java如下：

public class DDdogerProxy {
    /**
     * @param infc 被代理类实现的接口Class对象
     * @return
     * @throws Exception
     */
    public static Object newInstance(Class infc, DDdogerInvocationHandler h) throws Exception {
        //1 生成源码文件
        //1.1 声明一段源码，这里使用的是UnionProxy的源码进行稍加整理
        //其中Moveable需要根据传入的参数infc来确定
        //构建的代理类名取为$Proxy0，与jdk保持一致，当然也可以换成别的名字
        String methodStr = "";
        //循环获取被代理类的方法
        for(Method m : infc.getMethods()) {
            methodStr += 
                    "   @Override\r\n" + 
                    "   public void " + m.getName() + "() {\r\n" + 
                    "       try{\r\n" +
                    "           Method md = " + infc.getName() + ".class.getMethod(\"" + m.getName() + "\");" +
                    "           h.invoke(this, md);\r\n" + 
                    "       }catch(Exception e){e.printStackTrace();}\r\n" +
                    "   }";
        }
        String sourceStr = "package com.dddoger.proxy;\r\n" + 
                "import java.lang.reflect.Method;\r\n" + 
                "import com.dddoger.proxy.manual.DDdogerInvocationHandler;\r\n" + 
                "public class $Proxy0 implements "+ infc.getName() +" {\r\n" + 
                "   private DDdogerInvocationHandler h;\r\n" +
                "   public $Proxy0(DDdogerInvocationHandler h) {\r\n" + 
                "       this.h = h;\r\n" + 
                "   }\r\n" + 
                    methodStr +
                "}";
        //1.2 定义文件名，相对路径，位于工程目录下/bin/com/dddoger/proxy/$Proxy0.java
        String filename = System.getProperty("user.dir") +"/bin/com/dddoger/proxy/$Proxy0.java";
        File file = new File(filename);
        //1.3 这里使用的commons-io方便操作，生成源文件$Proxy0.java
        FileUtils.writeStringToFile(file, sourceStr);
        //2 编译源码文件
        //2.1 获取系统编译器
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        //2.2 通过cmopiler对象获取文件管理者对象
        StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
        //2.3 获取文件对象
        Iterable fileObjs = fileMgr.getJavaFileObjects(filename);
        //2.4 建立编译任务
        CompilationTask task = compiler.getTask(null, fileMgr, null, null, null, fileObjs);
        //2.5 开始编译任务
        task.call();
        //3 加载class文件到内存
        //3.1 获取类加载器
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        //3.2 加载指定的类到内存，我们只需要加载代理类$Proxy
        Class clazz = loader.loadClass("com.dddoger.proxy.$Proxy0");
        //4 使用构造器创建代理对象并返回
        //4.1 获取被代理类的构造器，参数为被代理类对象
        Constructor constructor = clazz.getConstructor(DDdogerInvocationHandler.class);
        //4.2 创建代理对象，并传入参数
        Object proxy = constructor.newInstance(h);
        return proxy;
    }
}

主要修改有以下几点：

newInstance方法中添加了事务处理器DDdogerInvocationHandler的h参数,DDdogerInvocationHandler在它的invoke方法中有预处理逻辑并反射调用了代理方法。
代理类$Proxy0.java要动态实现Moveable接口的所有方法，在方法内部使用反射调用事务处理器的方法。

for(Method m : infc.getMethods()) {
    methodStr += 
        "   @Override\r\n" + 
        "   public void " + m.getName() + "() {\r\n" + 
        "       try{\r\n" +
        "           Method md = " + infc.getName() + ".class.getMethod(\"" + m.getName() + "\");" +
        "           h.invoke(this, md);\r\n" + 
        "       }catch(Exception e){e.printStackTrace();}\r\n" +
        "   }";
}

生成$Proxy0的对象使用的参数也要对应改变

//4.1 获取被代理类的构造器，参数为被代理类对象
Constructor constructor = clazz.getConstructor(DDdogerInvocationHandler.class);
//4.2 创建代理对象，并传入参数
Object proxy = constructor.newInstance(h);

再测试一下：

target = new Bus();
BusHandler handler = new BusHandler(target);
//也就是说代理类和被代理类都实现了同一接口
Moveable m = (Moveable)DDdogerProxy.newInstance(Moveable.class, handler);
m.move();

输出结果：

确认司机身份中...
启动...
The Bus is moving
车辆行驶时间:137毫秒

这时我们的动态代理就基本实现了，只不过我们实现的事务处理器的invoke方法少一个args参数，返回值也为void,但是不影响我们整体的，我们暂时不再过多讨论。

Java代理模式及源码实现

代理模式简介

代理模式的几种实现方式

代理的实现

继承实现代理

聚合实现代理

动态代理

手动实现动态代理

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java代理模式及源码实现

代理模式简介

代理模式的几种实现方式

代理的实现

继承实现代理

聚合实现代理

动态代理

手动实现动态代理

热门文章

最新文章

相关课程

相关电子书

相关实验场景