Spring是如何实现AOP的

---

前言

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>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.3.18version>
        dependency>
        
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-aspectsartifactId>
            <version>5.3.18version>
        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 } XML element.
 * To be used on @{@link Configuration} classes as follows:
 */
 /**
  * 支持处理用 AspectJ 的 {@code @Aspect} 注释标记的组件，
  * 类似于 Spring 的 {@code } 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）、效果：
                      正常执行：前置通知-》目标方法-》后置通知-》返回通知
                      出现异常：前置通知-》目标方法-》后置通知-》异常通知

如有疑问和错误，欢迎大家指正，谢谢大家！