【Java杂记】代理：手动实现一个简易动态代理

╰半橙微兮° 2023-01-18 04:11 203阅读 0赞

Java 动态代理本质的本质就是通过代码写代码，即根据我们新定义的逻辑，实现接口，重新生成代理类

class $Proxy0 implements ~{
        
    	class InvocationHandler {
        
    		class Obj implements ~ {
        
    		}
    	}
    }
    
    调用逻辑: $Proxy0#f() -组装参数-> InvocationHandler#invoke() -控制访问-> Obj#f()

我们下面就来实现一个完全属于我们自己的动态代理…

### **要实现目标** ###

先从最终要达到的目标入手，看看我们需要实现哪些类

public interface Person {
        
        void findLove();
    }
    
    // 创建单身客户 Customer 类
    public class Customer implements Person {
        
        public void findLove() {
        
            System.out.println("高富帅就行了");
        }
    }
    
    // 实现 MyInvocationHandler 接口！！
    public class MyMeipo implements MyInvocationHandler {
        
    	
        // 被代理对象（依赖注入）
        private Object target;
        public Object getInstance(Object target) throws Exception{
        
            this.target = target;
            Class<?> clazz = target.getClass();
            // 核心！！！
            return MyProxy.newProxyInstance(new MyClassLoader(),clazz.getInterfaces(),this);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            before();
            // 调用被代理对象的当前方法
            Object obj = method.invoke(this.target,args);
            after();
           return obj;
        }
    
        private void before(){
        
            System.out.println("我是媒婆，负责找对象，现在已经确认需求");
            System.out.println("开始物色");
        }
    
        private void after(){
        
            System.out.println("OK的话，准备办事");
        }
    }

测试代码：

public class MyProxyTest {
        
    
        public static void main(String[] args) {
        
            try {
        
    			Person obj = (Person)new MyMeipo().getInstance(new Customer());
    			obj.findLove();
            }catch (Exception e){
        
                e.printStackTrace();
            }
        }
    }

可以看到，我们要实现的类有三个：

*  MyProxy：相当于一个工具类，负责生成代理类 $Proxy 的 java 代码，并将其编译，然后加载到 JVM
 *  MyClassLoader：负责加载指定 class 文件到虚拟机中
 *  MyInvocationHandler：接口，提供 invoke 方法

OK，我们来看一眼项目整体结构：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

下面我们逐一来实现…

### 1.MyProxy ###

/**
     * 相当于生成代理对象的工具类（写->创建）
     */
    public class MyProxy {
        
    
        // 换行符
        private static final String ln = "\r\n";
    
        public static Object newProxyInstance(MyClassLoader classLoader,
                                              Class<?>[] interfaces,
                                              MyInvocationHandler h) {
        
            try {
        
    
                // 1.生成动态代理类的代码
                String src = generateSrc(interfaces);
    
                // 2.将代码写入 .java 文件（target 目录下）
                // 获取当前类的位置，绝对路径
                String filePath = MyProxy.class.getResource("").getPath();
                // 创建一个新的 .java 文件
                // 注：代理类的编号依次从 0 递增，这里是直接写死了
                File f = new File(filePath + "$Proxy0.java");
                // 通过 FileWriter 写出到 .java 文件
                FileWriter fw = new FileWriter(f);
                fw.write(src);
                fw.flush();
                fw.close();
    
                // 3.将.java 文件编译成.class文件
                JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
                StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
                Iterable iterable = manage.getJavaFileObjects(f);
    
                JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
                task.call();
                manage.close();
    
                // 4.将编译生成的.class文件加载到JVM中
                // 注：加载到 JVM 即生成相应 Class 对象
                Class proxyClass =  classLoader.findClass("$Proxy0");
    
                // 5.生成代理对象实例
                // 获取当前代理类的构造器（入参是 InvocationHandler）
                Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
                f.delete(); // 将 java 文件删除
                // 入参是 Proxy.newProxyInstance() 传入的 InvocationHandler 实例
                return c.newInstance(h);
    
            }catch (Exception e){
        
                e.printStackTrace();
            }
                return null;
        }
    
        // 生成代理类的 java 代码
        // 本质就是拿代码写代码
        private static String generateSrc(Class<?>[] interfaces) {
        
    
            StringBuilder sb = new StringBuilder();
    
            sb.append("package com.yzh.myproxy;" + ln);
            // 反射相关依赖
            sb.append("import java.lang.reflect.*;" + ln);
            // 实现的接口也要引入
            // 为了方便这里直接写死了
            sb.append("import com.yzh.demo.Person;" + ln);
    
    
            sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
    
                sb.append("MyInvocationHandler h;" + ln);
                // 代理类的构造器，入参是 InvocationHandler
                sb.append("public $Proxy0(MyInvocationHandler h) {" + ln);
                    sb.append("this.h = h;" + ln);
                sb.append("}" + ln);
    
                /**
                 * 生成接口中的所有方法
                 *
                 * public 返回值类型 方法名(参数类型 参数名) {
                 *     Method m = 当前类.class。getMethod(方法名, new Class[]{参数类型数组});
                 *     return h.invoke(this, m, new Object[]{参数数组});
                 * }
                 */
                 for (Method m : interfaces[0].getMethods()) {
        
                     // 获取当前方法所有参数的类型
                     Class<?>[] params = m.getParameterTypes();
    
                     // 参数类型 参数名（，拼接）
                     StringBuilder paramNames = new StringBuilder();
                     // 参数名（，拼接）
                     StringBuilder paramValues = new StringBuilder();
                     // 参数类型（，拼接）
                     StringBuilder paramClasses = new StringBuilder();
    
                     for (int i = 0; i < params.length; i++) {
        
                         Class clazz = params[i];
                         String type = clazz.getName();
                         // 参数名 = 参数类型首字母小写
                         String paramName = toLowerFirstCase(clazz.getSimpleName());
    
                         paramNames.append(type + " " + paramName);
                         paramValues.append(paramName);
                         paramClasses.append(clazz.getName() + ".class");
    
                         // 逗号拼接
                         if (i > 0 && i < params.length - 1) {
        
                             paramNames.append(",");
                             paramClasses.append(",");
                             paramValues.append(",");
                         }
                     }
    
                     // public 返回值类型 方法名(参数类型 参数名)
                     sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
                        sb.append("try{" + ln);
                            // Method m = 当前类.class。getMethod(方法名, new Class[]{参数类型数组});
                            sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
                            // return h.invoke(this, m, new Object[]{参数数组});
                            // 注：如果返回类型为 void，则不需要 return，直接调用 invoke() 就行
                            sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
                        sb.append("}catch(Error _ex) {" + ln + "}");
                        sb.append("catch(Throwable e){" + ln);
                        sb.append("throw new UndeclaredThrowableException(e);" + ln);
                        sb.append("}");
                        // 如果 try 出现异常了，且 catch 未抛出异常
                        // 且当前方法有返回值
                        // 则需要 return 一个值，比如 return 0，return null
                        sb.append(getReturnEmptyCode(m.getReturnType()));
                     sb.append("}");
                 }
            sb.append("}" + ln);
            return sb.toString();
        }
    
        // 字符串首字母转小写
        private static String toLowerFirstCase(String src){
        
            char [] chars = src.toCharArray();
            chars[0] += 32;
            return String.valueOf(chars);
        }
    
        private static Map<Class,Class> mappings = new HashMap<>();
        static {
        
            mappings.put(int.class,Integer.class);
        }
    
        private static String getReturnEmptyCode(Class<?> returnClass){
        
            // 如果返回类型为 int，则 return 0;
            if(mappings.containsKey(returnClass)){
        
                return "return 0;";
            // 如果返回类型为 void，则直接 return;
            }else if(returnClass == void.class){
        
                return "";
            // 如果返回类型为其他（比如 Object），则 return null;
            }else {
        
                return "return null;";
            }
        }
    
        private static String getCaseCode(String code,Class<?> returnClass){
        
            if(mappings.containsKey(returnClass)){
        
                return "((" + mappings.get(returnClass).getName() +  ")" + code + ")." + returnClass.getSimpleName() + "Value()";
            }
            return code;
        }
    
        private static boolean hasReturnValue(Class<?> clazz){
        
            return clazz != void.class;
        }
    }

### 2.MyClassLoader ###

public class MyClassLoader extends ClassLoader{
        
    
        private File classPathFile;
        public MyClassLoader() {
        
            // 获取 ClassLoader 的绝对路径
            String classPath = MyClassLoader.class.getResource("").getPath();
            // 拿到 File 对象
            this.classPathFile = new File(classPath);
        }
    
        @Override
        // 根据类名将指定类加载进 JVM
        // 注：当一个类有 Class 对象了，就表示 JVM 将该类加载进来了
        protected Class<?> findClass(String name) throws ClassNotFoundException {
        
    
            // 拼接全类名
            String className = MyClassLoader.class.getPackage().getName() + "." + name;
            if(classPathFile  != null){
        
                // 根据绝对路径，以及 class 文件名，拿到 class 文件
                File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
                // 如果 class 文件存在
                if(classFile.exists()){
        
    
                    // 将 class 文件读入内存，暂存到一个字节数组中
                    FileInputStream in = null;
                    ByteArrayOutputStream out = null;
                    try{
        
                        in = new FileInputStream(classFile);
                        out = new ByteArrayOutputStream();
                        byte [] buff = new byte[1024];
                        int len;
                        while ((len = in.read(buff)) != -1){
        
                            out.write(buff,0,len);
                        }
    
                        // 构造类的 Class 对象
                        // 注：defineClass() 是一个 native 方法
                        return defineClass(className,out.toByteArray(),0,out.size());
                    }catch (Exception e){
        
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }
    }

### 3.MyInvocationHandler ###

public interface MyInvocationHandler {
        
    
        Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
    
    }

好了，至此所有代码我们就写完了，下面来把上面的目标代码运行一下，看看结果：

![在这里插入图片描述][20210430195107422.png_pic_center]  
没问题，完美运行！

> PS：完整代码我上传到 GitHub 了，感兴趣的同学可以点击[这里][Link 1]跳转…

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221021/1a64423719ee45c9b30fa0ae840fc1a6.png
[20210430195107422.png_pic_center]: /images/20221021/46500a5d15fd4591b6982cfcc8213f41.png
[Link 1]: https://github.com/YZHyaa/Framework/tree/main/myJdkDynamic