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

K_B_Z 发布于2019-08-16 13:33 / 2623人阅读

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

动态代理是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的二进制文件。

云服务器专线服务 java注册实现原理地图java实现原理 java线程池实现原理模拟实现

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/71942.html

2019年java架构师视频

摘要：并发专题一内存模型原理实现机制单例模式并发基础并发集合原子操作基本类型线程池互联网工程专题二简介安装工具编程介绍，入门程序仓库依赖管理简介常用操作命令 01.并发专题(一)2018-09-11(1)-Java内存模型2018-09-13(2)-synchronized原理2018-09-16(3)-volatile实现机制2018-09-18(4)-DCL-单例模式2018-09-21...

Object 2019-08-27 14:19 评论0 收藏0
Spring AOP的实现原理

摘要：使用与的静态代理不同，使用的动态代理，所谓的动态代理就是说框架不会去修改字节码，而是在内存中临时为方法生成一个对象，这个对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。 AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存...

ephererid 2019-08-14 15:54 评论0 收藏0
动态代理模式实现原理

摘要：代理模式概念代理模式分为两种，一种是静态代理模式，一种是动态代理模式。面向切面的编程也是使用动态代理模式来实现的。 1.代理模式概念代理模式分为两种，一种是静态代理模式，一种是动态代理模式。静态代理模式：在程序运行之前需要写好代理类动态代理模式：在程序运行期间动态生成代理类 2.动态代理的实现动态代理实现的步骤： (1)写一个代理类SubjectHandler实现Invoca...

songjz 2019-08-15 10:39 评论0 收藏0
Java反射-动态代理

摘要：动态代理有多种不同的用途，例如，数据库连接和事务管理用于单元测试的动态模拟对象其他类似的方法拦截。调用序列和下面的流程类似单元测试动态对象模拟利用动态代理实现单元测试的动态存根代理和代理。框架把包装成动态代理。使用反射可以在运行时动态实现接口。这可以使用类java.lang.reflect.Proxy。这个类的名称是我将这些动态接口实现称之为动态代理的原因。动态代理有多种不同的用途，...

Acceml 2019-08-16 13:24 评论0 收藏0
Java动态追踪技术探究

摘要：对于人类来说，字节码文件的可读性远远没有代码高。尽管如此，还是有一些杰出的程序员们创造出了可以用来直接编辑字节码的框架，提供接口可以让我们方便地操作字节码文件，进行注入修改类的方法，动态创造一个新的类等等操作。引子在遥远的希艾斯星球爪哇国塞沃城中，两名年轻的程序员正在为一件事情苦恼，程序出问题了，一时看不出问题出在哪里，于是有了以下对话： Debug一下吧。线上机器，没开Debu...

BlackFlagBin 2019-08-16 15:26 评论0 收藏0