AOP与JAVA动态代理

一时失言乱红尘 2022-04-15 06:08 262阅读 0赞

# AOP与JAVA动态代理 #

## 1、AOP的各种实现 ##

AOP就是面向切面编程，我们可以从以下几个层面来实现AOP  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70]  
在编译期修改源代码  
在运行期字节码加载前修改字节码  
在运行期字节码加载后动态创建代理类的字节码

## 2、AOP各种实现机制的比较 ##

以下是各种实现机制的比较：

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

## 3、AOP里的公民 ##

Joinpoint：拦截点，如某个业务方法  
Pointcut：Joinpoint的表达式，表示拦截哪些方法。一个Pointcut对应多个Joinpoint  
Advice：要切入的逻辑  
Before Advice：在方法前切入  
After Advice：在方法后切入，抛出异常则不会切入  
After Returning Advice：在方法返回后切入，抛出异常则不会切入  
After Throwing Advice：在方法抛出异常时切入  
Around Advice：在方法执行前后切入，可以中断或忽略原有流程的执行  
公民之间的关系

![在这里插入图片描述][20181122142838109.jpg]

织入器通过在切面中定义pointcout来搜索目标（被代理类）的JoinPoint（切入点），然后把要切入的逻辑（Advice）织入到目标对象里，生成代理类

## 4、AOP的实现机制 ##

动态代理  
动态字节码生成  
自定义类加载器  
字节码转换  
![在这里插入图片描述][2018112214285788.jpg]

### 4.1 动态代理 ###

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了

动态代理：即在运行期动态创建代理类，使用动态代理实现AOP需要4个角色：

被代理的类：即AOP里所说的目标对象  
被代理类的接口  
织入器：使用接口反射机制生成一个代理类，在这个代理类中织入代码  
InvocationHandler切面：切面，包含了Advice和Pointcut

#### 4.1.1 动态代理的演示 ####

例子演示的是在方法执行前织入一段记录日志的代码，其中

Business是代理类  
LogInvocationHandler是记录日志的切面  
IBusiness、IBusiness2是代理类的接口  
Proxy.newProxyInstance是织入器

public interface IBusiness { 
        void doSomeThing();
    }
    
    public interface IBusiness2 { 
        void doSomeThing2();
    }
    
    public class Business implements IBusiness, IBusiness2 { 
        @Override
        public void doSomeThing() { 
            System.out.println("执行业务逻辑");
        }
    
        @Override
        public void doSomeThing2() { 
            System.out.println("执行业务逻辑2");
        }
    }

package aop;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    /** * 打印日志的切面 */
    public class LogInvocationHandler implements InvocationHandler { 
    
        private Object target;//目标对象
    
        public LogInvocationHandler(Object target) { 
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            //执行织入的日志，你可以控制哪些方法执行切入逻辑
            if (method.getName().equals("doSomeThing2")) { 
                System.out.println("记录日志");
            }
            //执行原有逻辑
            Object recv = method.invoke(target, args);
            return recv;
        }
    }

package aop;
    
    import java.lang.reflect.Proxy;
    
    
    public class Main { 
        public static void main(String[] args) { 
            //需要代理的类接口，被代理类实现的多个接口都必须在这这里定义
            Class[] proxyInterface = new Class[] { IBusiness.class, IBusiness2.class};
            //构建AOP的Advice，这里需要传入业务类的实例
            LogInvocationHandler handler = new LogInvocationHandler(new Business());
            //生成代理类的字节码加载器
            ClassLoader classLoader = Business.class.getClassLoader();
            //织入器，织入代码并生成代理类
            IBusiness2 proxyBusiness = (IBusiness2) Proxy.newProxyInstance(classLoader, proxyInterface, handler);
            proxyBusiness.doSomeThing2();
            ((IBusiness)proxyBusiness).doSomeThing();
        }
    }

执行结果：  
记录日志  
执行业务逻辑2  
执行业务逻辑

#### 4.1.2 动态代理的原理 ####

本节将结合动态代理的源代码讲解其实现原理

动态代理的核心其实就是代理对象的生成，即Proxy.newProxyInstance(classLoader, proxyInterface, handler)

让我们进入newProxyInstance方法观摩下，核心代码就三行：

//获取代理类 
    Class cl = getProxyClass(loader, interfaces); 
    //获取带有InvocationHandler参数的构造方法 
    Constructor cons = cl.getConstructor(constructorParams); 
    //把handler传入构造方法生成实例 
    return (Object) cons.newInstance(new Object[] {  h });

getProxyClass(loader, interfaces)方法用于获取代理类，它主要做了三件事情：

在当前类加载器的缓存里搜索是否有代理类  
没有则生成代理  
并缓存在本地JVM里  
查找代理类getProxyClass(loader, interfaces)方法：

1 // 缓存的key使用接口名称生成的List 
     2 Object key = Arrays.asList(interfaceNames); 
     3 synchronized (cache) {  
     4     do {  
     5 Object value = cache.get(key); 
     6          // 缓存里保存了代理类的引用 
     7 if (value instanceof Reference) {  
     8     proxyClass = (Class) ((Reference) value).get(); 
     9 } 
    10 if (proxyClass != null) {  
    11 // 代理类已经存在则返回 
    12     return proxyClass; 
    13 } else if (value == pendingGenerationMarker) {  
    14     // 如果代理类正在产生，则等待 
    15     try {  
    16 cache.wait(); 
    17     } catch (InterruptedException e) {  
    18     } 
    19     continue; 
    20 } else {  
    21     //没有代理类，则标记代理准备生成 
    22     cache.put(key, pendingGenerationMarker); 
    23     break; 
    24 } 
    25     } while (true); 
    26 }

生成加载代理类：

//生成代理类的字节码文件并保存到硬盘中(默认不保存到硬盘) 
    proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces); 
    //使用类加载器将字节码加载到内存中 
    proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);

代理类生成过程ProxyGenerator.generateProxyClass()方法的核心代码分析：

//添加接口中定义的方法，此时方法体为空 
    for (int i = 0; i < this.interfaces.length; i++) {  
      localObject1 = this.interfaces[i].getMethods(); 
      for (int k = 0; k < localObject1.length; k++) {  
         addProxyMethod(localObject1[k], this.interfaces[i]); 
      } 
    } 
    
    //添加一个带有InvocationHandler的构造方法 
    MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1); 
    
    //循环生成方法体代码（省略） 
    //方法体里生成调用InvocationHandler的invoke方法代码。（此处有所省略） 
    this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;") 
    
    //将生成的字节码，写入硬盘，前面有个if判断，默认情况下不保存到硬盘。 
    localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class"); 
    localFileOutputStream.write(this.val$classFile);

通过以上分析，我们可以推出动态代理为我们生产了一个这样的代理类。把方法soSomeThing的方法体修改为调用LogInvocationHandler的invoke方法

代码如下：

public class ProxyBusiness implements IBusiness, IBusiness2 {  
    
    private LogInvocationHandler h; 
    
    @Override 
    public void doSomeThing2() {  
        try {  
            Method m = (h.target).getClass().getMethod("doSomeThing", null); 
            h.invoke(this, m, null); 
        } catch (Throwable e) {  
            // 异常处理（略） 
        } 
    } 
    
    @Override 
    public boolean doSomeThing() {  
        try {  
           Method m = (h.target).getClass().getMethod("doSomeThing2", null); 
           return (Boolean) h.invoke(this, m, null); 
        } catch (Throwable e) {  
            // 异常处理（略） 
        } 
        return false; 
    } 
    
    public ProxyBusiness(LogInvocationHandler h) {  
        this.h = h; 
    } 
    
    //测试用 
    public static void main(String[] args) {  
        //构建AOP的Advice 
        LogInvocationHandler handler = new LogInvocationHandler(new Business()); 
        new ProxyBusiness(handler).doSomeThing(); 
        new ProxyBusiness(handler).doSomeThing2(); 
    } 
    }

#### 4.1.3 小结 ####

从前两节的分析我们可以看出，动态代理在运行期通过接口动态生成代理类，这为其带来了一定的灵活性，但这个灵活性却带来了两个问题：

第一，代理类必须实现一个接口，如果没实现接口会抛出一个异常  
第二，性能影响，因为动态代理是使用反射机制实现的，首先反射肯定比直接调用要慢，其次使用反射大量生成类文件可能引起full gc，因为字节码文件加载后会存放在JVM运行时方法区（或者叫永久代、元空间）中，当方法区满时会引起full gc，所以当你大量使用动态代理时，可以将永久代设置大一些，减少full gc的次数

### 4.2 CGLIB动态字节码生成 ###

使用动态字节码生成技术实现AOP原理是在运行期间目标字节码加载后，生成目标类的子类，将切面逻辑加入到子类中，所以cglib实现AOP不需要基于接口

![在这里插入图片描述][20181122142954322.jpg]

本节介绍如何使用cglib来实现动态字节码技术。

cglib是一个强大的、高性能的Code生成类库，它可以在运行期间扩展Java类和实现Java接口，它封装了Asm，所以使用cglib前需要引入Asm的jar

#### 4.2.1 使用cglib实现AOP ####

1 package cglib;
     2 
     3 /** 4 * 这个是没有实现接口的实现类 5 */
     6 public class BookFacadeImpl { 
     7     public void addBook() { 
     8         System.out.println("增加图书的普通方法。。。");
     9     }
    10 
    11     public void deleteBook() { 
    12         System.out.println("删除图书的普通方法。。。");
    13     }
    14 }

1 package cglib;
     2 
     3 import net.sf.cglib.proxy.Enhancer;
     4 import net.sf.cglib.proxy.MethodInterceptor;
     5 import net.sf.cglib.proxy.MethodProxy;
     6 
     7 import java.lang.reflect.Method;
     8 
     9 /** 10 * 使用cglib动态代理 11 */
    12 public class BookFacadeCglib implements MethodInterceptor { 
    13 
    14     private Object target;
    15 
    16     /** 17 * 创建代理对象 18 * 19 * @param target 20 * @return 21 */
    22     public Object getInstance(Object target) { 
    23         this.target = target;
    24         Enhancer enhancer = new Enhancer();
    25         enhancer.setSuperclass(this.target.getClass());
    26         //回调方法
    27         enhancer.setCallback(this);
    28         //创建代理
    29         return enhancer.create();
    30     }
    31 
    32     //回调方法
    33     @Override
    34     public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 
    35         if (method.getName().equals("addBook")) { 
    36             System.out.println("记录增加图书的日志");
    37         }
    38         methodProxy.invokeSuper(obj, args);
    39         return null;
    40     }
    41 }

package cglib;
    
    /** * 测试cglib字节码代理 */
    public class TestCglib { 
        public static void main(String[] args) { 
            BookFacadeCglib cglib = new BookFacadeCglib();
            BookFacadeImpl bookFacade = (BookFacadeImpl) cglib.getInstance(new BookFacadeImpl());
            bookFacade.addBook();
            bookFacade.deleteBook();
        }
    }

执行结果：

记录增加图书的日志  
增加图书的普通方法。。。  
删除图书的普通方法。。。

### 4.3 自定义类加载器 ###

如果我们实现了一个自定义类加载器，在类加载到JVM之前直接修改某些类的方法，并将切入逻辑织入到这个方法里，然后将修改后的字节码文件交给虚拟机运行，那岂不是更直接  
![在这里插入图片描述][20181122143042472.jpg]

Javassist是一个编辑字节码的框架，可以让你很简单地操作字节码。它可以在运行期定义或修改Class。使用Javassist实现AOP的原理是在字节码加载前直接修改需要切入的方法

这比使用cglib实现AOP更加高效，并且没有太多限制，实现原理如下图：  
![在这里插入图片描述][20181122143102432.jpg]

我们使用类加载器启动我们自定义的类加载器，在这个类加载器里加一个类加载监听器，监听器发现目标类被加载时就织入切入逻辑

#### 4.3.1 Javassist实现AOP的代码 ####

清单1：启动自定义的类加载器

//获取存放CtClass的容器ClassPool 
    ClassPool cp = ClassPool.getDefault(); 
    //创建一个类加载器 
    Loader cl = new Loader(); 
    //增加一个转换器 
    cl.addTranslator(cp, new MyTranslator()); 
    //启动MyTranslator的main函数 
    cl.run("jsvassist.JavassistAopDemo$MyTranslator", args);

清单2：类加载监听器

public static class MyTranslator implements Translator {  
    
            public void start(ClassPool pool) throws NotFoundException, CannotCompileException {  
            } 
    
            /* * * 类装载到JVM前进行代码织入 */ 
            public void onLoad(ClassPool pool, String classname) {  
                if (!"model$Business".equals(classname)) {  
                    return; 
                } 
                //通过获取类文件 
                try {  
                    CtClass  cc = pool.get(classname); 
                    //获得指定方法名的方法 
                    CtMethod m = cc.getDeclaredMethod("doSomeThing"); 
                    //在方法执行前插入代码 
                    m.insertBefore("{ System.out.println(\"记录日志\"); }"); 
                } catch (NotFoundException e) {  
                } catch (CannotCompileException e) {  
                } 
            } 
    
            public static void main(String[] args) {  
                Business b = new Business(); 
                b.doSomeThing2(); 
                b.doSomeThing(); 
            } 
        }

输出：

执行业务逻辑2  
记录日志  
执行业务逻辑

#### 4.3.2 小结 ####

从本节中可知，使用自定义的类加载器实现AOP在性能上有优于动态代理和cglib，因为它不会产生新类，但是它仍人存在一个问题，就是如果其他的类加载器来加载类的话，这些类就不会被拦截

### 4.4 字节码转换 ###

自定义类加载器实现AOP只能拦截自己加载的字节码，那么有一种方式能够监控所有类加载器加载的字节码吗？

有，使用Instrumentation，它是Java5的新特性，使用Instrument，开发者可以构建一个字节码转换器，在字节码加载前进行转换

本节使用Instrumentation和javassist来实现AOP

#### 4.4.1 构建字节码转换器 ####

首先需要创建字节码转换器，该转换器负责拦截Business类，并在Business类的doSomeThing方法前使用javassist加入记录日志的代码

1 public class MyClassFileTransformer implements ClassFileTransformer {  
     2 
     3     /** 4 * 字节码加载到虚拟机前会进入这个方法 5 */ 
     6     @Override 
     7     public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, 
     8                             ProtectionDomain protectionDomain, byte[] classfileBuffer) 
     9             throws IllegalClassFormatException {  
    10         System.out.println(className); 
    11         //如果加载Business类才拦截 
    12         if (!"model/Business".equals(className)) {  
    13             return null; 
    14         } 
    15 
    16         //javassist的包名是用点分割的，需要转换下 
    17         if (className.indexOf("/") != -1) {  
    18             className = className.replaceAll("/", "."); 
    19         } 
    20         try {  
    21             //通过包名获取类文件 
    22             CtClass cc = ClassPool.getDefault().get(className); 
    23             //获得指定方法名的方法 
    24             CtMethod m = cc.getDeclaredMethod("doSomeThing"); 
    25             //在方法执行前插入代码 
    26             m.insertBefore("{ System.out.println(\"记录日志\"); }"); 
    27             return cc.toBytecode(); 
    28         } catch (NotFoundException e) {  
    29         } catch (CannotCompileException e) {  
    30         } catch (IOException e) {  
    31             //忽略异常处理 
    32         } 
    33         return null; 
    34 }

#### 4.4.2 注册转换器 ####

使用premain函数注册字节码转换器，该方法在main函数之前执行

public class MyClassFileTransformer implements ClassFileTransformer {  
        public static void premain(String options, Instrumentation ins) {  
            //注册我自己的字节码转换器 
            ins.addTransformer(new MyClassFileTransformer()); 
    } 
    }

4.4.3 配置和执行  
需要告诉JVM在启动main函数之前，需要先执行premain函数。

首先，需要将premain函数所在的类打成jar包，并修改jar包里的META-INF\\MANIFEST.MF文件

1 Manifest-Version: 1.0 
    2 Premain-Class: bci. MyClassFileTransformer

其次，在JVM的启动参数里加上-javaagent:D:\\java\\projects\\opencometProject\\Aop\\lib\\aop.jar

#### 4.4.4 输出 ####

执行main函数，你会发现切入的代码无侵入性的织入进去了

1 public static void main(String[] args) {  
    2    new Business().doSomeThing(); 
    3    new Business().doSomeThing2(); 
    4 } 
    5

输出：

1 model/Business 
     2 sun/misc/Cleaner 
     3 java/lang/Enum 
     4 model/IBusiness 
     5 model/IBusiness2 
     6 记录日志 
     7 执行业务逻辑 
     8 执行业务逻辑2 
     9 java/lang/Shutdown 
    10 java/lang/Shutdown$Lock

从输出中可以看到系统类加载器加载的类也经过了这里

5、AOP实战  
5.1 AOP功能  
性能监控：在方法调用前后记录调用时间，方法执行太长或超时报警  
缓存代理：缓存某方法的返回值，下次执行该方法时，直接从缓存里获取  
软件破解：使用AOP修改软件的验证类的判断逻辑  
记录日志：在方法执行前后记录系统日志  
工作流系统：工作流系统需要将业务代码和流程引擎代码混合在一起执行，那么我们可以使用AOP将其分离，并动态挂接业务  
权限验证：方法执行前验证是否有权限执行当前方法，没有则抛出没有权限执行异常，由业务代码捕捉

### 5.2 Spring的AOP ###

Spring默认采取动态代理机制实现AOP，当动态代理不可用时（代理类无接口）会使用cglib机制

但Spring的AOP有一定的缺点：

第一，只能对方法进行切入，不能对接口、字段、静态代码块进行切入（切入接口的某个方法，则该接口下所有实现类的该方法都将被切入）  
第二，同类中的互相调用方法将不会使用代理类。因为要使用代理类必须从Spring容器中获取Bean  
第三，性能不是最好的。从前面几节得知，我们自定义的类加载器，性能优于动态代理和cglib

public IMsgFilterService getThis() {  
    　　return (IMsgFilterService) AopContext.currentProxy(); 
    } 
    
    public boolean evaluateMsg () {  
    　　// 执行此方法将织入切入逻辑 
    　　return getThis().evaluateMsg(String message); 
    } 
    
    @MethodInvokeTimesMonitor("KEY_FILTER_NUM") 
    public boolean evaluateMsg(String message) {

public boolean evaluateMsg () {  
       // 执行此方法将不会织入切入逻辑 
    　　return evaluateMsg(String message); 
    } 
    
    @MethodInvokeTimesMonitor("KEY_FILTER_NUM") 
    public boolean evaluateMsg(String message) {

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70]: /images/20220415/c70fdc7f90c14585b5ce1551dd37d733.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 1]: /images/20220415/66954b647e0d4b539469a1896d327b8f.png
[20181122142838109.jpg]: /images/20220415/f9af6d1c82ec4d2d91e8b5a18b1c307d.png
[2018112214285788.jpg]: /images/20220415/0374380cd569482c94cfdb19649f4995.png
[20181122142954322.jpg]: /images/20220415/da7c4e391dde434297264168a446d695.png
[20181122143042472.jpg]: /images/20220415/bd119f109c9b434fb989d096f8fb59b4.png
[20181122143102432.jpg]: /images/20220415/09edc05123534036bb528fcacc4bb0b4.png