通过模拟JDK中的动态代理,由浅入深讲解动态代理思想.

目录

• 场景引入
• 动态代理引入
• 动态代理进阶
• 总结

个人认为动态代理在设计模式中算是比较难的, 本篇文章将从无到有, 从一个简单代码示例开始迭代, 逐步深入讲解动态代理思想.

场景引入

• 假设现在有一个坦克类, 它实现了Moveable接口, 里面有一个move()移动的方法. 代码如下:

class Tank implements Moveable{
    @Override
    public void move(){
        System.out.println("坦克开始移动...");
        try {
            Thread.sleep((long) (Math.random() * 5000));
            System.out.println("坦克移动结束...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

interface Moveable{
    public void move();
}

• 为了能计算坦克移动所花费的时间我们打算在坦克的move()方法的前后添加一些代码, 用于记录坦克move()方法的执行时间.
• 我们将使用代理类, 并在代理类中执行上述操作, 首先展示的是以继承的方式进行代理.

class MoveTimeProxy1 extends Tank{
    @Override
    public void move() {
        long start = System.currentTimeMillis();//开始时间
        super.move();//调用坦克的move()方法
        long end = System.currentTimeMillis();//结束时间
        System.out.println("执行该方法用了" + (end - start) + "毫秒");
    }
}

• 接着我们展示另外一种通过聚合实现代理的方式

class MoveTimeProxy2 implements Moveable{
    Tank tank;

    public MoveTimeProxy2(Tank tank){
        this.tank = tank;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();//开始时间
        tank.move();//调用坦克的move()方法
        long end = System.currentTimeMillis();//结束时间
        System.out.println("执行该方法用了" + (end - start) + "毫秒");
    }
}

• 以上两种均为实现代理的方式, 如果要分个优劣的话, 继承方式的代理会差一些. 想想看, 如果现在除了记录时间, 还要记录日志的话, 则要创建一个新的继承代理类并重写move()方法. 如果需求变更, 需要先记录日志, 再记录时间的话, 又要创建一个新的继承代理类. 如此下去, 代理类的创建将没完没了.
• 相比之下, 聚合实现的代理类则灵活得多. 每一个聚合代理类能够实现一种代理, 并且代理的顺序是可以替换的. 请看代码(聚合代理类的代码有所修改)

public class ProxyTest {

    public static void main(String[] args) {
        TimeProxy tp = new TimeProxy(new Tank());
        LogProxy lp = new LogProxy(tp);
        lp.move();
    }
}

class TimeProxy implements Moveable{//记录时间的代理
    Moveable m;//不再持有Tank引用, 而是持有Moveable接口引用

    public TimeProxy(Moveable m){
        this.m = m;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();//开始时间
        m.move();//调用move()方法
        long end = System.currentTimeMillis();//结束时间
        System.out.println("执行该方法用了" + (end - start) + "毫秒");
    }
}

class LogProxy implements Moveable{//打印日志的代理
    Moveable m;

    public LogProxy(Moveable m){
        this.m = m;
    }

    @Override
    public void move() {
        System.out.println("日志: 开始测试坦克移动...");
        m.move();
        System.out.println("日志: 坦克移动结束...");
    }
}

 

动态代理引入

• 看完上面的例子, 大家应该对代理一词有更深刻的理解. 但是上面的代码中, 为坦克生成的代理类TimeProxy是我们在代码中写死的, 所以这顶多算个静态代理, 如何通过动态的方式产生代理呢?
• 在讲解动态代理之前我们需要明确的是, 上面的聚合代理方式通过持有某个接口的引用完成代理, 所以我们是针对某个接口产生代理, 而不是对某个具体的对象产生代理.
• 为了模拟Java中的实现, 我们创建一个Proxy类, 里面提供一个newProxyInstance()方法, 用于返回一个代理. 我们希望通过如下代码就能动态生成一个代理.

public static void main(String[] args) {
    Tank tank = new Tank();
    Moveable m = (Moveable)Proxy.newProxyInstance();//动态获得一个代理
    m.move();
}

• 从上面的代码可以看到我们甚至都不需要知道代理类的名字就可以动态的获取一个代理. 我们以上述的记录时间的代理为例子, 获取一个时间代理类.
• 在newProxyInstance()方法中, 我们先把原来TimeProxy的源代码以字符串的方式存放, 再通过写入文件的方式创建出TimeProxy.java文件. 然后通过Java原生的编译api将TimeProxy.java编译成TimeProxy.class文件. 最后把该class文件加载到内存中, 并调用其构造方法创建对象, 返回该代理对象.
• 温馨提示: 本段代码不是专门教大家如何动态生成类, 因为有很多开源工具比如CGLib, ASM等可以更专业地完成这件事情, 这里仅使用Java原生API完成, 主要为了展现动态生成一个代理对象背后的过程.

class Proxy{
    public static Object newProxyInstance() throws Exception {
        //把整个TimeProxy类的实现写入字符串, 通过编译这一字符串得到TimeProxy对象
        String src = "package designPattern.proxy;\n" +
                "\n" +
                "class TimeProxy implements Moveable{\n" +
                "    Moveable m;//不再持有Tank引用, 而是持有Moveable接口引用\n" +
                "\n" +
                "    public TimeProxy(Moveable m){\n" +
                "        this.m = m;\n" +
                "    }\n" +
                "\n" +
                "    @Override\n" +
                "    public void move() {\n" +
                "        long start = System.currentTimeMillis();//开始时间\n" +
                "        m.move();//调用坦克的move()方法\n" +
                "        long end = System.currentTimeMillis();//结束时间\n" +
                "        System.out.println(\"执行该方法用了\" + (end - start) + \"毫秒\");\n" +
                "    }\n" +
                "}";
        String filename = System.getProperty("user.dir")
                + "/src/main/java/designPattern/proxy/TimeProxy.java";//文件名(生成类的路径)
        File f = new File(filename);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();

        //编译
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();//拿到系统当前默认的编译器, 即Javac
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileManager.getJavaFileObjects(filename);//得到文件对象
        JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, units);
        t.call();//进行编译
        fileManager.close();

        //把class文件加载进内存并创建对象
        URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
        URLClassLoader ul = new URLClassLoader(urls);
        Class c = ul.loadClass("designPattern.proxy.TimeProxy");//拿到class对象

        Constructor ctr = c.getConstructor(Moveable.class);//拿到参数为Moveable的构造方法
        Moveable m = (Moveable)ctr.newInstance(new Tank());//创建代理对象
        return m;
    }
}

• 我们继续对上面的代码进行优化, 目前代码中指定生成的是实现了moveable接口的代理对象. 而上面我们提到过动态代理是基于某个接口的(聚合型代理), 所以我们希望能够动态地指定接口, 并生成相应的代理类.

public class ProxyTest {

    public static void main(String[] args) throws Exception {
        Tank tank = new Tank();
        Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class);//传入接口参数动态获得一个代理
        m.move();
    }
}

class Proxy{
    public static Object newProxyInstance(Class intfce) throws Exception {
        //把整个TimeProxy类的实现写入字符串, 通过编译这一字符串得到TimeProxy对象
        String methodStr = "";
        String n = "\n";

        Method[] methods = intfce.getMethods();//拿到接口中的所有方法
        for(Method m : methods){//拼接方法
            methodStr += "    @Override\n" +
                    "    public void " + m.getName() + "() {\n" +
                    "        long start = System.currentTimeMillis();//开始时间\n" +
                    "        m.move();//调用坦克的move()方法\n" +
                    "        long end = System.currentTimeMillis();//结束时间\n" +
                    "        System.out.println(\"执行该方法用了\" + (end - start) + \"毫秒\");\n" +
                    "    }\n";
        }
        //拼接出整个类
        String src = "package designPattern.proxy;\n" +
                "\n" +
                "class TimeProxy implements " + intfce.getName() + "{\n" +
                "    Moveable m;//不再持有Tank引用, 而是持有Moveable接口引用\n" +
                "\n" +
                "    public TimeProxy(Moveable m){\n" +
                "        this.m = m;\n" +
                "    }\n" +
                "\n" + methodStr +
                "}";

        String filename = System.getProperty("user.dir")
                + "/src/main/java/designPattern/proxy/TimeProxy.java";//文件名(生成类的路径)
        File f = new File(filename);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();

        //编译
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();//拿到系统当前默认的编译器, 即Javac
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileManager.getJavaFileObjects(filename);//得到文件对象
        JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, units);
        t.call();//进行编译
        fileManager.close();

        //把class文件加载进内存并创建对象
        URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
        URLClassLoader ul = new URLClassLoader(urls);
        Class c = ul.loadClass("designPattern.proxy.TimeProxy");//拿到class对象

        Constructor ctr = c.getConstructor(Moveable.class);//拿到参数为Moveable的构造方法
        Object m = ctr.newInstance(new Tank());//创建代理对象
        return m;
    }
}

 

动态代理进阶

• 在上一个版本中我们已经能够动态地生成一个代理对象了, 但是还有一个最重要的也是最难的点没有实现. 在上面的代码中我们对被代理对象进行的操作是记录方法的运行时间, 是在代码里面写死的. 我们希望可以让用户自定义增强手段, 比如说记录时间(TimeProxy), 输出日志(LogProxy), 事务操作等等.
• 对于这种在被代理对象前后进行增强的操作, 我们定义一个InvocationHandler接口, 并在它的实现类中给出具体的操作. 我们以初始的记录时间操作为例.
• 下面给出完整的代码, 如果看不懂可以结合代码后面的总结来看.

public class ProxyTest {

    public static void main(String[] args) throws Exception {
        Tank tank = new Tank();
        InvocationHandler h = new TimeHandler(tank);
        Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);//动态获得一个代理
        m.move();
    }
}

interface InvocationHandler{
    public void invoke(Object o, Method m);//参数o指定执行对象(代理对象, 可能会用到), m指定执行的方法
}

class TimeHandler implements InvocationHandler{
    private Object target;

    public TimeHandler(Object target){
        this.target = target;
    }

    @Override
    public void invoke(Object o, Method m) {
        long start = System.currentTimeMillis();//这行是用户自己加的增强代码
        try{
            m.invoke(target);
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();//这行是用户自己加的增强代码
        System.out.println("执行该方法用了" + (end - start) + "毫秒");//这行是用户自己加的增强代码
    }
}

class Proxy{
    public static Object newProxyInstance(Class intfce, InvocationHandler h) throws Exception {
        //把整个TimeProxy类的实现写入字符串, 通过编译这一字符串得到TimeProxy对象
        String methodStr = "";

        Method[] methods = intfce.getMethods();//拿到接口中的所有方法
        for(Method m : methods){//拼接方法
            methodStr += "    @Override\n" +
                    "    public void " + m.getName() + "() {\n" +
                    "        try{\n" +
                    "        Method md = " + intfce.getName() + ".class.getMethod(\"" + m.getName() + "\");\n" +
                    "        h.invoke(this, md);\n" +
                    "        }catch(Exception e){e.printStackTrace();}\n" +
                    "    }\n";
        }
        //拼接出整个类
        String src = "package designPattern.proxy;\n" +
                "import java.lang.reflect.Method;\n" +
                "\n" +
                "class $Proxy1 implements " + intfce.getName() + "{\n" +
                "    designPattern.proxy.InvocationHandler h;\n" +
                "\n" +
                "    public $Proxy1(InvocationHandler h){\n" +
                "        this.h = h;\n" +
                "    }\n" +
                "\n" + methodStr +
                "}";

        String filename = System.getProperty("user.dir")
                + "/src/main/java/designPattern/proxy/$Proxy1.java";//文件名(生成类的路径)
        File f = new File(filename);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();

        //编译
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();//拿到系统当前默认的编译器, 即Javac
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileManager.getJavaFileObjects(filename);//得到文件对象
        JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, units);
        t.call();//进行编译
        fileManager.close();

        //把class文件加载进内存并创建对象
        URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
        URLClassLoader ul = new URLClassLoader(urls);
        Class c = ul.loadClass("designPattern.proxy.$Proxy1");//拿到class对象

        Constructor ctr = c.getConstructor(InvocationHandler.class);//拿到参数为Moveable的构造方法
        Object m = ctr.newInstance(h);//创建代理对象
        return m;
    }
}

class Tank implements Moveable{
    @Override
    public void move(){
        System.out.println("坦克开始移动...");
        try {
            Thread.sleep((long) (Math.random() * 5000));
            System.out.println("坦克移动结束...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//输出结果
坦克开始移动...
坦克移动结束...
执行该方法用了4302毫秒

 

总结

• 在这里有必要对上面整个动态代理的实现总结一下.
• 首先要明确我们是基于一个接口进行代理, 比如本文中给出了一个Moveable接口, 而Tank坦克类实现了Moveable接口, 并实现了move()方法.
• 现在我们想对move()方法进行增强, 比如说记录这个方法的执行时间, 我们需要动态地获得一个代理类.
• 而且为了让增强具有可扩展性, 我们创建了InvocationHandler接口, 里面有一个invoke(Object o, Method m)方法. 调用invoke()方法时, 需要传递两个参数, 一个是代理对象的引用o(可能会用上), 另一个是需要被增强的方法, 本例中是move()方法.
• 在invoke()方法中我们可以在被增强方法的前后添加增强代码.

public void invoke(Object o, Method m) {
    long start = System.currentTimeMillis();//这行是用户自己加的增强代码
    try{
        m.invoke(target);//执行被增强的方法, 例子中的move()
    } catch (Exception e) {
        e.printStackTrace();
    }
    long end = System.currentTimeMillis();//这行是用户自己加的增强代码
    System.out.println("执行该方法用了" + (end - start) + "毫秒");//这行是用户自己加的增强代码
}

• 补充一点, 要创建InvocationHandler的具体对象, 比如这里的TimeHander, 需要传入被增强的对象, 这里是tank, 因为被增强方法move()需要由被增强对象执行.

 

• 搞定InvocationHandler后, 回头看为我们动态产生代理的Proxy类, 这个类需要有一个属性字段InvocationHandler h, 因为在进行增强时, 调用的是InvocationHandler实现类中的invoke()方法. 在动态代理进阶一节的最后版本代码中, 我们动态生成的代理类源码是这样的:

class $Proxy1 implements designPattern.proxy.Moveable{
    designPattern.proxy.InvocationHandler h;

    public $Proxy1(InvocationHandler h){
        this.h = h;
    }

    @Override
    public void move() {
        try{
            Method md = designPattern.proxy.Moveable.class.getMethod("move");
            h.invoke(this, md);
        }catch(Exception e){e.printStackTrace();}
    }
}

• 由源码可以看到当调用代理类的move()方法进行增强时, 会调用InvocaitonHandler的实现类中的invoke()方法, 传入代理类自身和被增强的方法, 这样就可以使用自定义的增强代码进行增强了.

 

• 动态代理有什么好处?

1. 对于任意一个实现了某个接口的类, 我们都可以对其实现的接口中定义的方法进行增强.
2. 可以在被增强方法前后自定义增强的逻辑.
3. 可以进行多层嵌套代理.