AOP与JAVA动态代理

1、AOP的各种实现

AOP就是面向切面编程，我们可以从以下几个层面来实现AOP

在编译期修改源代码

在运行期字节码加载前修改字节码

在运行期字节码加载后动态创建代理类的字节码

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

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

类别	机制	原理	优点	缺点
静态AOP	静态织入	在编译期，切面直接以字节码的形式编译到目标字节码文件中	对系统无性能影响	灵活性不够
动态AOP	动态代理	在运行期，目标类加载后，为接口动态生成代理类，将切面织入到代理类中	相对于静态AOP更加灵活	切入的关注点需要实现接口。 对系统有一点性能影响
动态字节码生成	CGLIB	在运行期，目标类加载后，动态构建字节码文件生成目标类的子类，将切面逻辑加入到子类中	没有接口也可以织入	扩展类的实例方法为final时，则无法进行织入
自定义类加载器		在运行期，目标加载前，将切面逻辑加到目标字节码里	可以对绝大部分类进行织入	代码中如果使用了其他类加载器，则这些类将不会被织入
字节码转换		在运行期，所有类加载器加载字节码前进行拦截	可以对所有类进行织入

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) {