Spring是如何实现AOP的
- 前言
- 一、AOP是什么？
- 二、个人理解
- 2.1 配置
- 2.2 源码
- 总结
前言
AOP即面向切面编程，是一种编程思想，作为面向对象思想的补充，目的是方便增强方法，处理一些具有横切性质的服务，比如日志记录，安全控制等，强大的Spring框架中亦运用了这种思想，那在探究了Spring实现AOP过程之后，在这里记录下自己的理解；
一、AOP是什么？
理解AOP之前，我们先回顾一下OOP(面向对象编程)，众所周知，OOP的特点是继承、封装、多态，其中封装的一个目的就是把方法与类进行松耦合，在使用的时候，不同的类可以方便的调用各自的功能，说白了就是代码分散，增加代码重用性，降低代码复杂度。但是当代码分散的时候，也带来一个问题，打个比方，假如现在有两个类都要使用同一个日志打印方法，那根据OOP的思想，我需要在两个类中调用这个方法，但是注意这个独立的方法是在一个独立的类中，这样调用类和方法类就有了明显的耦合关系，独立方法类的改变会影响到调用类，那么有什么办法可以随意的加入代码的，那AOP就是做这样的事情，在程序预编译或者动态运行时，把公共操作切入类的指定方方法和指定位置处，这个就是面向切面编程（AOP），用一张图来表示AOP的思想：
如图所示，前者在不同的业务线中都插入了验证用户的代码，后者是把验证用户的代码，横向的切入到业务中（为了展示切入过程，放大了线条，实质上这种切入是不用修改业务的原来的代码的），Spring框架就具有这种能力，其关键就是运用了代理模式
二、个人理解
理解了代理模式之后，对SpringAOP的理解从两个方面入手：
2.1 配置
本节介绍spring中关于AOP的配置以及涉及的常见AOP相关术语
1.常见AOP术语
- JoinPoint(连接点):指的是那些被拦截的点，在spring中这些点就是一个一个的方法。
- PointCut(切入点):指的是我们定义的想要拦截的点
注意： 连接点相当于菜单（spring中所有方法都可以是连接点），切入点才是真正的我们想点的菜 - Advice(通知)：通知就是指作用到切入点上的具体方法，分为前置通知（Before）、后置通知（After）、环绕通知（Around）等。
- Aspect(切面或者方面):切面就是多个切点和通知的集合。
- Target(目标对象)：代理的目标对象(要增强的类)
- Weaving(织入)：把切面应用到目标对象来创建新的代理对象的过程就叫织入。Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
- Proxy(代理)：目标类被增强以后，会生成结果代理类。
2.Spring中关于AOP的配置
这里直接上示例：
创建一个maven类型的spring项目，这里就不赘述了,直接上pom.xml中的依赖引入部分
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.18</version>
</dependency>
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.18</version>
</dependency>
</dependencies>创建一个带有@Aspect注解的方面类，这个就是Spring中关于Aspect的具体表现形式：
@Aspect
//方面类（用 @Aspect 修饰的类）和其他类一样可以
// 有方法、属性定义，还可能包括切入点、增强处理定义。
public class LogAspects {
……
}填充切面类：
@Aspect
//方面类（用 @Aspect 修饰的类）和其他类一样可以
// 有方法、属性定义，还可能包括切入点、增强处理定义。
public class LogAspects {
//连接点就默认为项目中所有方法了
//设置切点
@Pointcut("execution(public int com.deee.springaop.MathCalculator.*(..))")
public void pointCut(){ }
@Before("pointCut()")
public void logStart(JoinPoint joinPoint){
Object[] args = joinPoint.getArgs();
System.out.println(" "+joinPoint.getSignature().getName()+"运行。。@Before的参数列表是：{"+Arrays.asList(args)+"}");
}
@After("pointCut()")
public void logEnd(JoinPoint joinPoint){
System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
}
//JoinPoint一定要出现在参数表的第一位
@AfterReturning(value="pointCut()",returning="result")
public void logReturn(JoinPoint joinPoint,Object result){
System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
}
@AfterThrowing(value = "pointCut()",throwing = "e")
public void logException(JoinPoint joinPoint,Exception e){
System.out.println(" "+joinPoint.getSignature().getName()+"异常。。异常信息：{"+e+"}");
}
}定义一个目标类,作为切入点：
package com.deee.springaop;
public class MathCalculator {
public int div(int i,int j){
System.out.println("MathCalculator...div...");
return i/j;
}
}然后是项目的配置类，这里就是把切面类和目标类注册到spring容器中，否则spring啥都不知道
@EnableAspectJAutoProxy//表示指定cglib代理方式
//使用上面的注解需要添加aspectjweaver环境，虽然aspectjweaver依赖对于 {@code spring-aop} 通常是可选的，但对于 {@code @EnableAspectJAutoProxy} 及其底层设施是必需的。
@Configuration
public class MainConfigOfAOP {
//把业务逻辑类和切面类放入spring容器中
@Bean
public MathCalculator mathCalculator(){
return new MathCalculator();
}
@Bean
public LogAspects logAspects(){
return new LogAspects();
}
}以上就是一个完整的springAOP示例，然后来个测试类便于分析
public class testSpringAop {
public static void main(String[] args) {
AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
MathCalculator bean = annotationConfigApplicationContext.getBean(MathCalculator.class);
bean.div(1,2);
annotationConfigApplicationContext.close();
}
}运行结果：
2.2 源码
本节从代码层面谈spring是如何做到上述过程的：从配置类开始看，因为这里是让spring开始认识项目的入口，常规操作是在此类中注册了本项目的两个组件，分别是切面类和目标类，但是有个关键注解，@EnableAspectJAutoProxy从此开始分析
查看该注解的定义：
//源码中对该注解有详细作用表达和示例描述，这里是截取关键部分并作翻译：
/**
* Enables support for handling components marked with AspectJ's {@code @Aspect} annotation,
* similar to functionality found in Spring's {@code <aop:aspectj-autoproxy>} XML element.
* To be used on @{@link Configuration} classes as follows:
*/
/**
* 支持处理用 AspectJ 的 {@code @Aspect} 注释标记的组件，
* 类似于 Spring 的 {@code <aop:aspectj-autoproxy>} XML 元素中的功能。
* 用于@{@link Configuration} 类，如下所示：
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
/**
* 指示是否要创建基于子类 (CGLIB) 的代理
* 而不是标准的基于 Java 接口的代理。 默认值为 {@code false}。
*/
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
/**
* 表示代理应该被 AOP 框架公开为 {@code ThreadLocal}
* 通过 {@link org.springframework.aop.framework.AopContext} 类进行检索。
* 默认关闭，即不保证 {@code AopContext} 访问将起作用。
* @since 4.3.1
*/
boolean exposeProxy() default false;
}这是这个注解的详细定义，你会发现其中引入了AspectJAutoProxyRegistrar组件
@Import(AspectJAutoProxyRegistrar.class)点进去发现
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
/**
* Register, escalate, and configure the AspectJ auto proxy creator based on the value
* of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
* {@code @Configuration} class.
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy =AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}那么这个类是用来干什么的呢？官方解释如下，直接看中文译文：
/**
* Registers an {@link org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
* AnnotationAwareAspectJAutoProxyCreator} against the current {@link BeanDefinitionRegistry}
* as appropriate based on a given @{@link EnableAspectJAutoProxy} annotation.
*/
/**
* 根据给定的 @{@link EnableAspectJAutoProxy} 注解，
* 针对当前的 {@link BeanDefinitionRegistry}，注册一个AnnotationAwareAspectJAutoProxyCreator {@link org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator }
*/那么AnnotationAwareAspectJAutoProxyCreator又是什么？还有BeanDefinitionRegistry又是什么？我点进去看了看官方解释，
其中对AnnotationAwareAspectJAutoProxyCreator的解释:
/**
* {@link AspectJAwareAdvisorAutoProxyCreator} subclass that processes all AspectJ
* annotation aspects in the current application context, as well as Spring Advisors.
*/翻译过来大概就是AnnotationAwareAspectJAutoProxyCreator是处理当前spring容器中的所有带有@Aspect注解的类（AspectJAwareAdvisorAutoProxyCreator）的子类（它继承了AspectJAwareAdvisorAutoProxyCreator），也叫Spring Advisors。
这个玩意儿的实现类图如下：可以看到继承了父类，父类又继承了巴拉巴拉，这里大量运用工厂模式
然后BeanDefinitionRegistry的官方定义如下：
/**
* Interface for registries that hold bean definitions, for example RootBeanDefinition
* and ChildBeanDefinition instances. Typically implemented by BeanFactories that
* internally work with the AbstractBeanDefinition hierarchy.
*/翻译过来大概就是：BeanDefinitionRegistry是注册bean的接口，例如 RootBeanDefinition和 ChildBeanDefinition 这样的bean实例。 这个接口通常是由内部采用AbstractBeanDefinition 机制的BeanFactories 来实现的，名词有很多，一句话，这就是注册bean的接口。
小总结：上面说了这么多，其实一句话就能概括了，@EnableAspectJAutoProxy做了一件事情，那就是通过AspectJAutoProxyRegistrar给容器中注册一个AnnotationAwareAspectJAutoProxyCreator。
关于这件事情在代码中怎么完成的，产生了什么效果，有空再继续梳理：
大家看完上面的解释，再往里面挖的时候，好像感觉有点迷糊的，因为好多概念不知所云，所以在分割线处，特意做个一个对比，先不管spring的aop，只需要对代码增强的基本思路有所了解，增强代码无非就是在方法前后加入一些代码，那天才们提出 一种思想，就是代理模式，代理模式中肯定不能少了代理类呀，关于代理模式点这里,所以同样的，因为切面的原理是代理模式，所以spring实现切面也不能脱离代理模式呀，那spring中如何为被代理对象生成代理类呢，看懂这个，即使看不懂，你也大概能里理解spring为什么是个牛逼的框架了。分割线上说了个名词叫AnnotationAwareAspectJAutoProxyCreator,这个东西就是一个bean后置处理器，其中的bean就是被代理对象，所以这个处理器就是为被代理对象生成aop代理类的，如果不知道它有啥用，可以看看代理模式中哪些为被代理对象生成代理类的东西长啥样，实际也是个类，java是用自带的，cglib是无中生有的那种，关于spring为了构建这个东西，费了多大劲，请看此图：
所以回到分割线之前所讲的，AnnotationAwareAspectJAutoProxyCreator（bean后置处理器）是为BeanDefinitionRegistry生成代理类，BeanDefinitionRegistry里面包含了所有的要被代理的bean，哪些类需要被代理，那么要看EnableAspectJAutoProxy注解的位置。至此应该讲清楚了上文的来龙去脉。
所以这里不再细讲，直接分两步梳理springAOP如何完成的，有时间和兴趣大家可以自行研究
总共分成两大步：
1.目标方法被代理并创建代理示例的过程，
流程：
1）、传入配置类，创建ioc容器
2）、注册配置类，调用refresh（）刷新容器；
3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
2）、给容器中加别的BeanPostProcessor
3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
5）、注册没实现优先级接口的BeanPostProcessor；
6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；
创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
1）、创建Bean的实例
2）、populateBean；给bean的各种属性赋值
3）、initializeBean：初始化bean；
1）、invokeAwareMethods()：处理Aware接口的方法回调
2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
3）、invokeInitMethods()；执行自定义的初始化方法
4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
7）、把BeanPostProcessor注册到BeanFactory中；
beanFactory.addBeanPostProcessor(postProcessor);
=======以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程========
AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean
1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
getBean->doGetBean()->getSingleton()->
2）、创建bean
【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，
会调用postProcessBeforeInstantiation()】
1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；
只要创建好的Bean都会被缓存起来
2）、createBean（）;创建bean；
AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例
【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】
【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】
1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续
1）、后置处理器先尝试返回对象；
bean = applyBeanPostProcessorsBeforeInstantiation（）：
拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;
就执行postProcessBeforeInstantiation
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；
3）、
AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】 的作用：
1）、每一个bean创建之前，调用postProcessBeforeInstantiation()；
关心MathCalculator和LogAspect的创建
1）、判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，
或者是否是切面（@Aspect）
3）、是否需要跳过
1）、获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】
每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；
判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
2）、永远返回false
2）、创建对象
postProcessAfterInitialization；
return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
1）、获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
2、获取到能在bean使用的增强器。
3、给增强器排序
2）、保存当前bean在advisedBeans中；
3）、如果当前bean需要增强，创建当前bean的代理对象；
1）、获取所有增强器（通知方法）
2）、保存到proxyFactory
3）、创建代理对象：Spring自动决定
JdkDynamicAopProxy(config);jdk动态代理；
ObjenesisCglibAopProxy(config);cglib的动态代理；
4）、给容器中返回当前组件使用cglib增强了的代理对象；
5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；2.目标方法被拦截并执行的过程
3）、目标方法执行 ；
容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；
1）、CglibAopProxy.intercept();拦截目标方法的执行
2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
1）、List<Object> interceptorList保存所有拦截器 5
一个默认的ExposeInvocationInterceptor 和 4个增强器；
2）、遍历所有的增强器，将其转为Interceptor；
registry.getInterceptors(advisor);
3）、将增强器转为List<MethodInterceptor>；
如果是MethodInterceptor，直接加入到集合中
如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
转换完成返回MethodInterceptor数组；
3）、如果没有拦截器链，直接执行目标方法;
拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
4）、如果有拦截器链，把需要执行的目标对象，目标方法，
拦截器链等信息传入创建一个 CglibMethodInvocation 对象，
并调用 Object retVal = mi.proceed();
5）、拦截器链的触发过程;
1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
拦截器链的机制，保证通知方法与目标方法的执行顺序；总结
1）、 @EnableAspectJAutoProxy 开启AOP功能
2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；
4）、容器的创建流程：
1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean
1）、创建业务逻辑组件和切面组件
2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
3）、组件创建完之后，判断组件是否需要增强
是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
5）、执行目标方法：
1）、代理对象执行目标方法
2）、CglibAopProxy.intercept()；
1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；
3）、效果：
正常执行：前置通知-》目标方法-》后置通知-》返回通知
出现异常：前置通知-》目标方法-》后置通知-》异常通知如有疑问和错误，欢迎大家指正，谢谢大家！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
