Java动态代理实现原理(模拟实现)

摘要：很多框架底层都使用了的动态代理技术来实现的，比如大名鼎鼎的这篇文章将带你一步一步揭开动态代理技术的神秘面纱。接下来客户端就可以这样使用了毫秒到目前为止，我们实现的类可以为任何接口生成代理类了，是不是很神奇。

​ 动态代理是java语言中常用的设计模式，java在1.3版本以后也提供了动态代理技术，允许开发者在运行期间创建接口的代理对象。 很多框架底层都使用了java的动态代理技术来实现的，比如大名鼎鼎的springAOP；这篇文章将带你一步一步揭开JDK动态代理技术的神秘面纱。

​ 我们先来定义一个接口：

package com.yanghui.study.proxy;
public interface IFlyable {
    int fly(int x,int y);
}

再来一个实现类：

package com.yanghui.study.proxy;
public class Plane implements IFlyable{
    @Override
    public int fly(int x, int y) {
        int result = x * x + y * y;
        try {
            Thread.sleep(new Random().nextInt(700));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }
}

如果我们要统计一下这个fly方法的运行时间，该怎么做呢？很简单，可以修改源码在方法fly方法里面加上两句代码①、②，这样就打印出方法的运行时间了，如下：

//省略不必要代码......
public int fly(int x, int y) {
    long start = System.currentTimeMillis();//①记录开始时间
    int result = x * x + y * y;
    try {
        Thread.sleep(new Random().nextInt(700));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("time:" + (System.currentTimeMillis() - start) + "毫秒");//②结束时间减去开始时间
    return result;
}

但是如果我们没有这个方法的源码，这个类是别人写好打好jar包提供给我们用的，这时如果你还想统计下这个方法运行时间，又该怎么办呢？至少有两种方式可以来实现：

1、使用继承，写一个类继承Plane，重写fly方法，在调用父类的fly方法前后加上①②处的代码，这样就可以统计fly方法的执行时间了。

package com.yanghui.study.proxy;
public class PlaneTimerProxy1 extends Plane{
    @Override
    public int fly(int x, int y) {
        long start = System.currentTimeMillis();//①
        int result = super.fly(x, y);
        System.out.println("time:" + (System.currentTimeMillis() - start) + "毫秒");//②
        return result;
    }
}

2、使用聚合的方式，写一个类PlaneTimerProxy2实现跟Plane一样的接口，并且持有IFlyable的引用，当调用fly方法时，实际调用的是IFlyable的fly方法，这样就可以在方法调用前后加上①②处的代码统计fly方法的执行的时间。

public class PlaneTimerProxy2 implements IFlyable{
    private IFlyable flyable;
    public PlaneTimerProxy2(IFlyable flyable) {
        this.flyable = flyable;
    }
    @Override
    public int fly(int x, int y) {
        long start = System.currentTimeMillis();//①
        int result = this.flyable.fly(x, y);
        System.out.println("time:" + (System.currentTimeMillis() - start) + "毫秒");//②
        return result;
    }
}

这两种方式都可以实现，那么哪种方式更好呢？答案是聚合的方式更好，为什么呢？想象一下，如果我还想实现更多的功能，比如给fly方法执行前后加上日志，事务控制，权限控制，这时用继承的方式你会需要新建更多的类来实现，可能你会想，聚合的实现方式不也是要新建更多的类来实现吗？是的，但是如果我要你先记录日志再记录时间，有如果我要你先记录时间再记录日志，需要实现这样随意的组合的功能，继承就显得很麻烦了，而聚合的方式就会很灵活了。在思考下，如果想给不同类的100个方法记录下时间和日志，那么你想想看是不是要产生100个代理类呢？类的数量又在不停的膨胀了。如果我们能够为实现了某个接口的类动态生成代理类就好了？想法很好，先来新建一个类Proxy，提供一个方法newProxyInstance,这个方法可以为一个实现了IFlyable接口的类产生代理类，那么客户端调用就可以这样做：

package com.yanghui.study.proxy.custom;
public class Client {
    public static void main(String[] args) {
        IFlyable flyable = (IFlyable)Proxy.newProxyInstance();
        flyable.fly(1, 2);
    }
}

那么我们如何在newProxyInstance方法里面动态的生成一个代理类呢？为了模拟JDK的实现，先定义一个接口InvocationHandler:

package com.yanghui.study.proxy.custom;
import java.lang.reflect.Method;
public interface InvocationHandler {
    Object invoke(Object proxy,Method method,Object[] args)throws Throwable;
}

下面来个完整代码：

public class Proxy {
    private static final Map bytesMap = new HashMap<>();
    private static final AtomicInteger count = new AtomicInteger();
    public static Object newProxyInstance(Class intaface,InvocationHandler handler) {
        //代码①处
        String rn = "
";
        String className = "Proxy" + count.getAndIncrement();
        String str = "package com.yanghui.study.proxy.custom;" + rn +
                     "public class " + className + " implements " + intaface.getName() + "{" + rn +
                     "    private InvocationHandler handler;" + rn +
                     "    public " + className + "(InvocationHandler handler){" + rn + 
                     "        this.handler=handler;" + rn + 
                     "    }" + rn;
        
        String methodStr = "";
        for(Method m : intaface.getMethods()) {
            methodStr = methodStr + "    @Override" + rn +
             "    public " + m.getReturnType().getName() + " " + m.getName() + "(";
            String parameterStr = "";
            String psType = "";
            String pname = "";
            for(Parameter p : m.getParameters()) {
                parameterStr = parameterStr + p + ",";
                psType = psType + p.getType().getName() + ".class,";
                pname = pname + p.getName() + ",";
            }
            if(!parameterStr.equals("")) {
                parameterStr = parameterStr.substring(0, parameterStr.length() - 1);
            }
            parameterStr = parameterStr + "){" + rn + 
                     "        try{" + rn +
                     "            " + Method.class.getName() + " method = " + intaface.getName() + ".class.getDeclaredMethod("" + m.getName() + """;
            if(!psType.equals("")) {
                psType = psType.substring(0, psType.length() - 1);
                parameterStr = parameterStr + "," + psType + ");" + rn;
            }else {
                parameterStr = parameterStr + ");" + rn;
            }
            if(pname.length() > 0) {
                pname = pname.substring(0, pname.length() - 1);
            }
            String returnStr = "";
            if(!"void".equals(m.getReturnType().getName())) {
                returnStr = returnStr + "            return (" + m.getReturnType().getName() + ")";
            }
            parameterStr = parameterStr + 
                    returnStr + "this.handler.invoke(this,method," + (pname.length() == 0 ? "null" : "new Object[]{" + pname + "}") + ");" + rn +
             "        } catch (Throwable e) {" + rn +
             "        throw new RuntimeException(e);" + rn +
             "    }" + rn +
             "    }" + rn;
            methodStr = methodStr + parameterStr;
        }
        String endStr = "}";
        str = str + methodStr + endStr;
        String path = Thread.currentThread().getContextClassLoader().getResource("").getPath() + "com/yanghui/study/proxy/custom/";
        String fileStr = path + className + ".java";
        //代码②处
        //写入文件
        writeToFile(fileStr, str);
        //代码③处
        //动态编译
        String className1 = "com.yanghui.study.proxy.custom." + className;
        return compileToFileAndLoadclass(className1, fileStr, handler);
    }
    
    /**
     * 从源文件到字节码文件的编译方式
     * @param className
     * @param fileStr
     * @param handler
     * @return
     */
    private static Object compileToFileAndLoadclass(String className,String fileStr,InvocationHandler handler) {
        //获取系统Java编译器
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        //获取Java文件管理器
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        //定义要编译的源文件
        File file = new File(fileStr);
        //通过源文件获取到要编译的Java类源码迭代器，包括所有内部类，其中每个类都是一个 JavaFileObject，也被称为一个汇编单元
        Iterable compilationUnits = fileManager.getJavaFileObjects(file);
        //生成编译任务
        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, compilationUnits);
        //执行编译任务
        task.call();
        try {
            fileManager.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            Class c = Thread.currentThread().getContextClassLoader().loadClass(className);
            Constructor ct = c.getConstructor(InvocationHandler.class);
            Object object = ct.newInstance(handler);
            return object;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    private static void writeToFile(String file,String context) {
        FileWriter fw = null;
        try {
            fw = new FileWriter(new File(file));
            fw.write(context);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

我来解释下上面代码的意思：

1、代码①处，根据传入的接口动态生成java代码的字符串，类名取名为Proxy+序号，该类实现了传入的接口，真正的方法调用将委托传入InvocationHandler的实现类来实现。

2、代码②处，将生成的java代码的字符串写入文件

3、代码③处，真正的核心，动态编译2步生成的java文件，再通过classLoader把编译生成的class文件加载进内存，然后反射创建实例。

接下来客户端就可以这样使用了：

public class Client {
    public static void main(String[] args) {
        Plane plane = new Plane();
        IFlyable flyable = (IFlyable)Proxy.newProxyInstance(IFlyable.class,new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                long start = System.currentTimeMillis();
                Object result = method.invoke(plane, args);
                System.out.println("time:" + (System.currentTimeMillis() - start) + "毫秒");
                return result;
            }
        });
        System.out.println(flyable.fly(1, 2));
    }
}

到目前为止，我们实现的Proxy类可以为任何接口生成代理类了，是不是很神奇。当然我们这里只是模拟实现了JDk的动态代理，还有很多细节是没有考虑的，有兴趣的同学可以自己阅读JDK源码，相信您理解了其背后的原理后，看起来也不会太费力了。

扩展

在上面我们实现了动态生成java文件，动态编译java文件，需要把文件写入磁盘，也会在java源文件的目录生成编译后的.class文件，那么可以不可以只在内存中编译加载呢？答案是可以的，代码如下(方法是Proxy类下的方法)：

/**
     * 从内存到内存的编译方式
     * @param className
     * @param code
     * @param handler
     * @return
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private static Object compileMemoryToMemoryAndLoadClass(String className,String code,InvocationHandler handler) {
        if(bytesMap.get(className) != null) {
            return loadClass(className, bytesMap.get(className), handler);
        }
        //获取系统Java编译器
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        //获取Java文件管理器
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        ForwardingJavaFileManager fjf = new ForwardingJavaFileManager(fileManager) {
            @Override
            public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind,
                    FileObject sibling) throws IOException {
                if(kind == JavaFileObject.Kind.CLASS) {
                    return new SimpleJavaFileObject(URI.create(""), JavaFileObject.Kind.CLASS) {
                        public OutputStream openOutputStream() {
                            return new FilterOutputStream(new ByteArrayOutputStream()) {
                                public void close() throws IOException{
                                    out.close();
                                    ByteArrayOutputStream bos = (ByteArrayOutputStream) out;
                                    bytesMap.put(className, bos.toByteArray());
                                }
                            };
                        }
                    };
                }else{
                    return super.getJavaFileForOutput(location, className, kind, sibling);
                }
            }
        };
        
        SimpleJavaFileObject sourceJavaFileObject = new SimpleJavaFileObject(URI.create(className.replace(".", "/") + Kind.SOURCE.extension),JavaFileObject.Kind.SOURCE){
            @Override
            public CharBuffer getCharContent(boolean b) {
                return CharBuffer.wrap(code);
            }
        };
        //生成编译任务
        JavaCompiler.CompilationTask task = compiler.getTask(null, fjf, null, null, null, Arrays.asList(new JavaFileObject[] {sourceJavaFileObject}));
        //执行编译任务
        task.call();
        try {
            fileManager.close();
            fjf.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return loadClass(className, bytesMap.get(className), handler);
    }
    
    private static Object loadClass(String className,byte[] bytes,InvocationHandler handler) {
        try {
            Class c = new MyClassLoader(bytes).loadClass(className);
            Constructor ct = c.getConstructor(InvocationHandler.class);
            Object object = ct.newInstance(handler);
            return object;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

首先通过自己定义sourceJavaFileObject类来加载java格式的字符串，通过ForwardingJavaFileManager类来重新定义编译文件的输出行为，这里我直接写入内存，用一个map(bytesMap)来保存,key就是类名，value就是编译好的.class的二进制文件。