AOP与JAVA动态代理

AOP与JAVA动态代理

1、AOP的各种实现

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

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

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

在这里插入图片描述

3、AOP里的公民

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

在这里插入图片描述

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

4、AOP的实现机制

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

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不需要基于接口

在这里插入图片描述

本节介绍如何使用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之前直接修改某些类的方法,并将切入逻辑织入到这个方法里,然后将修改后的字节码文件交给虚拟机运行,那岂不是更直接
在这里插入图片描述

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

这比使用cglib实现AOP更加高效,并且没有太多限制,实现原理如下图:
在这里插入图片描述

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

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) { 
展开阅读全文

没有更多推荐了,返回首页