Spring AOP 实现机制

我会带着你远行 2022-08-21 08:45 180阅读 0赞

（1）AOP的各种实现

在编译器修改源代码、在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码。以下是各种实现机制的比较：

类别分为静态AOP（包括静态织入）和动态AOP（包括动态代理、动态字节码生成、自定义类加载器、字节码转换）。

静态织入：

a、原理：在编译期，切面直接以字节码形式编译到目标字节码文件中 ；

b、优点：对系统性能无影响；

c、缺点：不够灵活；

动态代理 ：

a、原理：在运行期，目标类加载后，为接口动态生成代理类。将切面织入到代理类中；

b、优点：更灵活；

c、缺点：切入的关注点要实现接口；

动态字节码生成：

a、原理：在运行期，目标类加载后，动态构建字节码文件生成目标类的子类，将切面逻辑加入到子类中；

b、优点：没有接口也可以织入；

c、缺点：扩展类的实例方法为final时，无法进行织入；

自定义类加载器

a、原理：在运行期，目标加载前，将切面逻辑加到目标字节码里；

b、优点：可以对绝大部分类进行织入；

c、缺点：代码中若使用了其它类加载器，则这些类将不会被织入；

字节码转换

a、原理：在运行期，所有类加载器加载字节码前进行拦截；

b、优点：可以对所有类进行织入；

c、缺点：

（2）

Joinpoint：拦截点，如某个业务方法；

Pointcut：Jointpoint的表达式，表示拦截哪些方法。一个Pointcut对应多个Joinpoint；

Advice：要切入的逻辑。

Before Advice：在方法前切入；

After Advice：在方法后切入，抛出异常时也会切入；

After Returning Advice：在方法返回后切入，抛出异常不会切入；

After Throwing  Advice：在方法抛出异常时切入；

Around Advice：在方法执行前后切入，可以中断或忽略原有流程的执行；

目标                      切面                        织入器                代理类

Jointpoint            Advice

Pointcut

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

（3）动态代理的实现

[Java][]在JDK1.3后引入的动态代理机制，使我们可以在运行期动态的创建代理类。

使用动态代理实现AOP需要四个角色：被代理的类、被代理类的接口、织入器（Proxy.newProxyInstance()）、InvocationHandler。织入器使用接口反射机制生成一个代理类，然后在这个代理类中织入代码（切入逻辑）。InvocationHandler是切面，包含了Advice和Pointcut。

动态代理在运行期通过接口动态生成代理类。

使用反射大量生成类文件可能引起Full GC造成性能影响，因为字节码文件加载后会 存放在JVM运行时区的方法区中（或持久代）。当方法区满的时候，会引起Full GC。因此当大量使用动态代理时，可以将持久代设置大一些，减少Full GC次数。

动态代理的核心其实就是代理对象的生成，即Proxy.newProxyInstance()。其中getProxyClass()方法用于获取代理类，主要做了三件事：在当前类加载器的缓存里搜索是否有代理类，没有则生成代理类并缓存在本地JVM里。

可以使用JD-GUI反编译软件打开jre\\lib\\rt.jar。

动态代理生成的代理类，类似于：

public class ProxyBusiness implements IBusiness \{

private InvocationHandler h;

public ProxyBusiness(InvocationHandler h) \{

this.h = h;

public void doSomeThing() \{

tyr\{

Method m = (h.target).getClass().getMethod("doSomeThing", null);

h.invoke(this, m , null);

\}  catch(Throwable e) \{

//测试

public static void main(String\[\] args) \{

LogInvocationHandler handler = new LogInvocationHandler(new Business());

new ProxyBusiness(handler).doSomeThing();

代理的目的是调用目标方法时转而执行InvocationHandler类的invoke方法！

（4）动态字节码生成

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

使用Cglib实现动态字节码：

Cglib是高性能的code生成类库，可以在运行期间扩展java类和实现java接口。它封装了Asm，使用Cglib前要引入Asm的jar。

如：

public static void byteCodeGe() \{

//创建一个织入器

Enhancer enhancer = new Enhancer();

//设置父类

enhancer.setSuperclass(Business.class);

//设置需要织入的逻辑

enhancer.setCallback(new LogIntercept());

//使用织入器创建子类

IBusiness newBusiness = (IBusiness)enhancer.create();

newBusiness.doSomeThing();

public class LogIntercept implements MethodInterceptor \{

public Object intercept(Object target, Method method, Object\[\] args, MethodProxy proxy) throws Throwable \{

//执行原有逻辑，注意这里是invokeSuper

Object rev = proxy.invokeSuper(target, args);

//执行织入的日志

if(method.getName().equals("doSomeThing")) \{

System.out.println("记录日志");

return rev;

（5）自定义类加载器

实现一个自定义类加载器，在类加载到JVM之前直接修改类的方法，并将切入逻辑织入到这个方法里，然后将修改后的字节码文件交给JVM运行。

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

原理：

系统类加载器——>启动——>自定义类加载器（类加载监听器）——>载入——>类文件

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

启动自定义的类加载器：

//获取存放CtClass的容器ClassPool

ClassPool cp = ClassPool.getDefault();

//创建一个类加载器

Loader cl = new Loader();

//增加一个转换器

cl.addTranslator(cp, new MyTranslator());

//启动MyTranslator的main函数

cl.run("javassist.JavassistAopDemo$MyTranslator", args);

类加载监听器：

public static class MyTranslator implements Translator \{

public void start(ClassPool  pool) throws Exception \{

/\*\*类加载到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(Exception) \{

public static void main(String\[\] args) \{

Business b = new Business();

b.doSomeThing();

CtClass是一个class文件的抽象描述。可以使用insertAfter()在方法的末尾插入代码，使用insertAt()在指定行插入代码。

使用自定义的类加载器实现AOP在性能上要优于动态代理和Cglib，因为它不会产生新类。但存在一个问题，就是若其他的类加载器来加载类的话，这些类将不会被拦截。

（6）字节码转换

自定义的类加载器实现AOP只能拦截自己加载的字节码，有没有能够监控所有类加载器加载字节码？——>有，使用Instrumentation，它是Java 5提供的新特性。使用Instrumentation可以构建一个字节码转换器，在字节码加载前进行转换。使用Instrumentation和javassist实现AOP。

一、构建字节码转换器

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

public class MyClassFileTransformer implements ClassFileTransformer \{

/\*\*字节码加载到JVM前会进入这个方法\*/

public byte\[\] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte\[\] classfileBuffer)  throws Exception\{

//若加载Business类才拦截

if(!"model/Business".equals(className)) \{

return null;

//javassist的包名是用点分割的，要转换下

if(className.indexOf("/") != -1) \{

className = className.replaceAll("/", ".");

try\{

//通过包名获取类文件

CtClass cc = ClassPool.getDefault().get(className);

//获得指定方法名的方法

CtMethod m = cc.getDeclaredMethod("doSomeThing");

//在方法执行前插入代码

m.insertBefore("\{System.out.println(\\"记录日志\\");\}");

return cc.toBytecode();

\}catch (Exception e) \{

return null;

二、注册转换器

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

public class MyClassFileTransformer implements ClassFileTransformer \{

public static void premain(String options, Instrumentation ins) \{

//注册自己的字节码转换器

ins.addTransformer(new MyClassFileTransformer());

三、配置和执行

需要告诉JVM在启动main函数之前，需要先执行premain函数。首先需要将premain函数所在的类打成jar包。并修改该jar包里的META-INF\\MANIFEST.MF文件。

Manifest-Version:1.0

Premain-Class:bci. MyClassFileTransformer

然后在JVM的启动参数里加上：

\-javaagent:D:\\java\\projects\\opencometProject\\Aop\\lib\\aop.jar

四、输出

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

public static void main(String\[\] args) \{

new Business().doSomeThing();

2、PS

（1）AOP能做的事情：

性能监控：在方法调用前后记录调用时间，方法执行太长或超时报警。

缓存代理：缓存某方法的返回值，下次执行该方法时，直接从缓存里获取。

软件破解：使用AOP修改软件的验证类的判断逻辑。

工作流系统：工作流系统需要将业务代码和流程引擎代码混合在一起执行，可以使用AOP将其分离，并动态挂接业务。

权限验证：方法执行前验证是否有权限执行当前方法。

（2）方法调用成功后——>统计调用次数——>存入缓存服务器——>每日存入[数据库][Link 1]

因为每天的方法调用次数近百万，为了降低数据库压力不能实时入库。

一、如何使用：

只要配置了注解的方法将会被统计调用次数。

@MethodInvokeTimesMonitor(value="aaa", returnValue=false)

public void aa() \{

二、如何配置：

使用AspectJ的方式配置AOP。需要启动对AspectJ的支持。

<aop:aspectj-autoproxy proxy-target-class="true"/>

true表示让[spring][Java]使用Cglib实现AOP，配置为false表示使用动态代理实现AOP，默认使用动态代理。

三、定义注解

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface MethodInvokeTimesMonitor\{

String value();

boolean returnValue() default true;

四、定义切面，在切面中定义拦截的方法和在方法返回后记录调用次数的Advice。在这里定义拦截所有配置了注解的方法。

@Aspect

public class MethodAspect \{

/\*\*切入点，所有配置MethodInvokeTimesMonitor注解的方法\*/

@Pointcut("@annotation(org.cendy.MethodInvokeTimesMonitor)")

public void allMethodInvokeTimesMonitor() \{

/\*\*统计方法的调用次数\*/

@AfterReturning(value="MethodAspect.allMethodInvokeTimesMonitor() && @annotation(methodInvokeTimesMonitor)", returning="retVal")

public void statInvokeTimes(MethodInvokeTimesMonitor methodInvokeTimesMonitor, Object retVal)

String name = methodInvokeTimesMonitor.value();

boolean returnValue = methodInvokeTimesMonitor.returnValue();

.....

其中@Pointcut用于定义切入点表达式。@AfterReturning表示在方法执行后进行切入，里面的MethodAspect.allMethodInvokeTimesMonitor()表示使用这个方法的切入点表达式，@annotation(methodInvokeTimesMonitor)表示将当参数传递给statInvokeTimes()方法，returning="retVal"表示将被切入方法的返回值赋值给retVal，并传递给statInvokeTimes()方法。

（3）spring默认采用动态代理机制实现AOP，当动态代理不可用时（代理类无接口）会使用Cglib机制。

使用spring的AOP缺点：

a、只能对方法进行切入，不能对接口、属性、静态代码块进行切入（切入接口的某个方法，则该接口下所有实现类的该方法将被切入）

b、同类中的互相调用方法将不会使用代理类。因为要使用代理类必须从spring容器中获取bean。

获取代理类，如：

public IMsgFilterService getThis() \{

return (IMsgFilterService)AopContext.currentProxy();

**1 AOP各种的实现**

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

![77bd18fc-0e29-3e25-9447-9ccb9a25a9a8.jpg][]

在编译器修改源代码，在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码，以下是各种实现机制的比较。

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

**2 AOP里的公民 **

*  Joinpoint：拦截点，如某个业务方法。
 *  Pointcut：Joinpoint的表达式，表示拦截哪些方法。一个Pointcut对应多个Joinpoint。
 *  Advice:  要切入的逻辑。
 *  Before Advice 在方法前切入。
 *  After Advice 在方法后切入，抛出异常时也会切入。
 *  After Returning Advice 在方法返回后切入，抛出异常则不会切入。
 *  After Throwing Advice 在方法抛出异常时切入。
 *  Around Advice 在方法执行前后切入，可以中断或忽略原有流程的执行。 
 *  公民之间的关系   
    ![84ffee2b-bb05-3d3f-8fc4-5b6c7851cea5.jpg][]  
    织入器通过在切面中定义pointcut来搜索目标（被代理类）的JoinPoint(切入点)，然后把要切入的逻辑（Advice）织入到目标对象里，生成代理类。

**3 AOP的实现机制 **  
  本章节将详细介绍AOP有各种实现机制。

**3.1 动态代理 **  
  Java在JDK1.3后引入的动态代理机制，使我们可以在运行期动态的创建代理类。使用动态代理实现AOP需要有四个角色：被代理的类，被代理类的接口，织入器，和InvocationHandler，而织入器使用接口反射机制生成一个代理类，然后在这个代理类中织入代码。被代理的类是AOP里所说的目标，InvocationHandler是切面，它包含了Advice和Pointcut。   
![f9d3a3b2-605c-3d01-8488-970d254acb88.jpg][]  
  
**3.1.1 使用动态代理**   
  那如何使用动态代理来实现AOP。下面的例子演示在方法执行前织入一段记录日志的代码，其中Business是代理类，LogInvocationHandler是记录日志的切面，IBusiness, IBusiness2是代理类的接口，Proxy.newProxyInstance是织入器。   
清单一：动态代理的演示