spring (六) 应用：spring aop 动态代理

悠悠 2022-12-13 14:17 210阅读 0赞

java中的proxy - 设计模式 - 代理模式

--------------------

## **什么是代理** ##

增强一个对象的功能

买火车票、app就是一个代理，他代理了火车站，小区当中的代售窗口

--------------------

## **java实现的代理的两种方式** ##

> 静态代理
> 
> 动态代理

**代理的名词**

代理对象  增强后的对象

目标对象 被增强的对象

他们不是绝对的，会根据情况发生变化

### **静态代理** ###

> 继承 聚合

**继承**

代理对象继承目标对象，重写需要增强的方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70][]

缺点：代理类会过多，非常复杂

**聚合**

目标对象和代理对象实现同一个接口，代理对象当中要包含目标对象

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 1][]

缺点：会出现类爆炸，稍微比继承少点

> 总结：在不确定的情况下，尽量不要去使用静态代理。因为一旦写代码，就会产生类，一旦产生类就会爆炸

### 动态代理 ###

>  动态代理：  
>  自己模拟的动态代理  
>    
>  不需要手动创建类文件（因为一旦手动创建类文件，就会产生类爆炸），通过接口反射生成一个类文件，然后调用第三方的编译技术，动态编译这个产生的类文件成class文件，继而利用UrlClassLoader（**因为这个动态产生的class不在工程当中，所以需要使用URLClassLoader**）  
>  把这个动态编译的类加载到jvm当中，最后通过反射把这个类实例化

import javax.tools.JavaCompiler;
    import javax.tools.StandardJavaFileManager;
    import javax.tools.ToolProvider;
    import java.io.File;
    import java.io.FileWriter;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    import java.net.URL;
    import java.net.URLClassLoader;
    
    public class ProxyUtil {
    
        /**
         *  content --->string
         *  .java  io
         * .class
         *
         *
         *
         * .new   反射----》class
         * @return
         */
        public static Object newInstance(Object target) {
            // 继承的接口
            Object proxy = null;
            Class targetInf = target.getClass().getInterfaces()[0];
            Method methods[] = targetInf.getDeclaredMethods();
            String line = "\n";
            String tab = "\t";
            String infName = targetInf.getSimpleName();
            String content = "";
            String packageContent = "package com.luban;" + line;
            String importContent = "import " + targetInf.getName() + ";" + line;
            String clazzFirstLineContent = "public class $Proxy implements " + infName + "{" + line;
            String filedContent = tab + "private " + infName + " target;" + line;
            String constructorContent = tab + "public $Proxy (" + infName + " target){" + line
                                      + tab + tab + "this.target = target;"
                                      + line + tab + "}" + line;
            String methodContent = "";
            for (Method method : methods) {
                String returnTypeName = method.getReturnType().getSimpleName();
                String methodName = method.getName();
                // String.class String.class
                Class args[] = method.getParameterTypes();
                String argsContent = "";
                String paramsContent = "";
                int flag = 0;
                for (Class arg : args) {
                    String temp = arg.getSimpleName();
                    // String
                    // String p0, String p1,
                    argsContent += temp + " p" + flag + ",";
                    paramsContent += "p" + flag + ",";
                    flag++;
                }
    
                if (argsContent.length() > 0) {
                    argsContent = argsContent.substring(0, argsContent.lastIndexOf(",") - 1);
                    paramsContent = paramsContent.substring(0, paramsContent.lastIndexOf(",") - 1);
                }
                methodContent += tab + "public " + returnTypeName + " " + methodName + "(" + argsContent + ") {" + line
                               + tab + tab + "System.out.println(\"log\");" + line;
    
                               if (returnTypeName.equals("void")) {
                                   methodContent += tab + tab + "target." + methodName + "(" + paramsContent + ");" + line
                                           + tab + "}" + line;
                               } else {
                                   methodContent += tab + tab + "return target." + methodName + "(" + paramsContent + ");" + line
                                           + tab + "}" + line;
                               }
            }
    
            content = packageContent + importContent + clazzFirstLineContent + filedContent + constructorContent + methodContent + "}";
    
            File file = new File("d:\\com\\luban\\$Proxy.java");
            try {
                if (!file.exists()) {
                    file.createNewFile();
                }
    
                FileWriter fw = new FileWriter(file);
                fw.write(content);
                fw.flush();
                fw.close();
    
                // 动态编译
                JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
                StandardJavaFileManager fileManager = compiler.getStandardFileManager(null,null,null);
                Iterable units = fileManager.getJavaFileObjects(file);
    
                JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null,null,units);
                t.call();
                fileManager.close();
    
                URL[] urls = new URL[]{new URL("file:D:\\\\")};
    
                // 动态产生的class不在项目工程中，所以需要URLClassLoader
                URLClassLoader urlClassLoader = new URLClassLoader(urls);
                Class clazz = urlClassLoader.loadClass("com.luban.$Proxy");
    //            Class.forName() 只能加载本包下的文件
    
                // 确定构造方法 -- 确定构造方法需要根据参数进行确认
                Constructor constructor = clazz.getConstructor(targetInf);
    
                // java中一切皆对象，通过newInstance构造一个对象
                proxy = constructor.newInstance(target);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            /**
             * public UserDaoLog(UserDao target){
             * 		this.target =target;
             *
             *        }
             */
            return proxy;
        }
    }

然后在main方法进行调用

public class Test {
    
        public static void main(String[] args) {
    
            /// 自定义动态代理
            UserDao proxy = (UserDao) ProxyUtil.newInstance(new UserDaoImpl());
    //        System.out.println(proxy.proxy("luban"));
            proxy.query();
        }
    }

相关的方法可以实现日志和时间的记录操作

生成后产生的代理类$Proxy为

package com.luban;
    import com.luban.dao.UserDao;
    public class $Proxy implements UserDao{
    	private UserDao target;
    	public $Proxy (UserDao target){
    		this.target = target;
    	}
    	public void query() {
    		System.out.println("log");
    		target.query();
    	}
    	public void query(String p) {
    		System.out.println("log");
    		target.query(p);
    	}
    	public String proxy(String p) {
    		System.out.println("log");
    		return target.proxy(p);
    	}
    }

缺点：首先要生成文件

缺点：动态编译文件 class

缺点：需要一个URLclassloader

软件性能的最终体现在IO操作

# #

**JDK动态代理**

自动检测

> 通过接口反射得到字节码，然后把字节码转成class native openJDK c++

**cglib**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70]: /images/20221123/a01ad92e8af7455da8f46912b291625c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 1]: /images/20221123/f7b518d65fa14583b5194a945be6a10d.png