Spring注解驱动开发——AOP原理

一. AOP功能测试

①. pom.xml 依赖导入

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
<!--        <version>4.3.12.RELEASE</version>-->
        </dependency>

②. 目标类

package com.xizi.aop;

public class MathCalculator {
    //除法
    public int div(int i, int j) {
        System.out.println("MathCalculator...div...");
        return i / j;
    }
}

③. 切面类

package com.xizi.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Arrays;

//告诉Spring当前类是一个切面类
@Aspect
public class LogAspects {

    //抽取公共的切入点表达式
    //本类引用：pointCut()
    //其他的切面类要引用
    @Pointcut("execution(public int com.xizi.aop.MathCalculator.*(..))")
    public void pointCut() {

    }

    //@Before在目标方法之前切入：切入点表达式（指定在哪个方法切入）
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint) {
        System.out.println(joinPoint.getSignature().getName()+"除法运行...参数列表是：{"+ Arrays.asList(joinPoint.getArgs()) +"}");
    }
    @After("pointCut()")
    public void logEnd(JoinPoint joinPoint) {
        System.out.println(joinPoint.getSignature().getName()+"除法结束...");
    }
    @AfterReturning(value = "pointCut()",returning = "result")
    public void logReturn(Object result) {
        System.out.println("除法正常返回...运行结果为：{"+result+"}");
    }
    //JoinPoint这个参数一定要出现在参数列表的第一位
    @AfterThrowing(value = "pointCut()",throwing = "exception")
    public void logException(JoinPoint joinPoint,Exception exception) {
        System.out.println(joinPoint.getSignature().getName()+"除法异常...异常信息为：{"+exception+"}");
    }

//    @Around("pointCut()")
//    public void logAround() {
//        System.out.println("除法环绕通知");
//    }
}

④. 配置类

package com.xizi.config;

/**
 *  AOP:【动态代理】
 *      能在程序运行期间动态的将某段代码片段切入到指定的方法指定位置进行运行的编程方式；
 *
 *  1、导入aop模块，Spring AOP：(spring-aspects)
 *  2、定义一个业务逻辑类（MathCalculator），在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、包括方法出现异常等等）
 *  3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里了然后执行
 *      切面类里面的方法就是通知方法：
 *      （1）前置通知（@Before）：logStart，在目标方法（div）运行之前运行
 *      （2）后置通知（@After）：logEnd，在目标方法（div）运行之前运行
 *      （3）返回通知（@AfterReturning）：logReturn，在目标方法（div）执行返回（无论是正常返回还是异常返回）之后运行
 *      （4）异常通知（@AfterThrowing）：logException，在目标方法（div）出现异常之后运行
 *      （5）环绕通知（@Around）：动态代理，手动推进目标方法运行（joinPoint.procced()）
 *  4、给切面类的目标方法标注何时何地运行（通知注解）
 *  5、将切面类和业务逻辑类（目标方法所在的类）都加入到容器中；
 *  6、必须要告诉Spring哪一个类是切面类（只要给切面类上加上一个注解：@Aspect）
 *  【7】、给配置类中加入@EnableAspectJAutoProxy：开启基于注解的aop模式
 */
@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {

    //将业务逻辑类加入到容器中
    @Bean
    public MathCalculator mathCalculator() {
        return new MathCalculator();
    }

    //将切面类加入到容器中
    @Bean
    public LogAspects logAspects() {
        return new LogAspects();
    }
}

⑤. 测试类

    @Test
    public void test01() {
        AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

        //从容器中获取代理的组件
        MathCalculator mathCalculator = ioc.getBean(MathCalculator.class);
        mathCalculator.div(1, 1);
    }

  AOP：【动态代理】
  		指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

  1、导入aop模块；Spring AOP：(spring-aspects)
  2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）
  3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
  		通知方法：
  			前置通知(@Before)：logStart：在目标方法(div)运行之前运行
  			后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
  			返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
  			异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
  			环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
  4、给切面类的目标方法标注何时何地运行（通知注解）；
  5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;
  6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
  [7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
  		在Spring中很多的 @EnableXXX;

  三步：
  	1）、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
  	2）、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
   3）、开启基于注解的aop模式；@EnableAspectJAutoProxy

二. AOP原理-@EnableAspectJAutoProxy

①. 给容器中导入AspectJAutoProxyRegistrar

②. 利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion

③. 给容器中注册一个AnnotationAwareAspectJAutoProxyCreator

④. AnnotationAwareAspectJAutoProxyCreator继承关系

⑤. 关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

⑥. AbstractAutoProxyCreator.setBeanFactory()

⑦. AbstractAutoProxyCreator.有后置处理器的逻辑

⑧. AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()

⑨. AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

  AOP原理：【看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？】
  		@EnableAspectJAutoProxy；
  1、@EnableAspectJAutoProxy是什么？
  		@Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar
  			利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion
  			internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

  		给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；

  2、 AnnotationAwareAspectJAutoProxyCreator：
  		AnnotationAwareAspectJAutoProxyCreator
  			->AspectJAwareAdvisorAutoProxyCreator
  				->AbstractAdvisorAutoProxyCreator
  					->AbstractAutoProxyCreator
  							implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
  						关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

  AbstractAutoProxyCreator.setBeanFactory()
  AbstractAutoProxyCreator.有后置处理器的逻辑；

  AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()

  AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

三. 创建和注册AnnotationAwareAspectJAutoProxyCreator的过程

①. 注册配置类，调用refresh（）刷新容器

②. registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建

③. 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

④. 给容器中加别的BeanPostProcessor

⑤. 优先注册实现了PriorityOrdered接口的BeanPostProcessor

⑥. 创建internalAutoProxyCreator的BeanPostProcessor

⑦. invokeAwareMethods()：处理Aware接口的方法回调

⑧. 应用后置处理器的postProcessBeforeInitialization（）

⑨. 执行自定义的初始化方法

⑩. 执行后置处理器的postProcessAfterInitialization（）

十一. 把BeanPostProcessor注册到BeanFactory中

四. AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】 的作用

①. 每一个bean创建之前，调用postProcessBeforeInstantiation()

②. 关心MathCalculator和LogAspect的创建

③. 获取候选的增强器（切面里面的通知方法）【List candidateAdvisors】

④. 判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean

⑤. 判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true

五. 创建对象

①. wrapIfNecessary()

②. 获取当前bean的所有增强器（通知方法） Object[] specificInterceptors

③. 保存当前bean在advisedBeans中

④. 如果当前bean需要增强，创建当前bean的代理对象

⑤. 给容器中返回当前组件使用cglib增强了的代理对象

⑥. 以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程

六. 目标方法执行

①. 容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；

②. CglibAopProxy.intercept();拦截目标方法的执行

③. 根据ProxyFactory对象获取将要执行的目标方法拦截器链

④. 如果没有拦截器链，直接执行目标方法

⑤. 如果有拦截器链，把需要执行的目标对象，目标方法

⑥. 拦截器链的触发过程

七. 链式调用通知方法

拦截器链的触发过程:
  	1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
  	2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
  		拦截器链的机制，保证通知方法与目标方法的执行顺序；

八. AOP-原理总结

  	总结：
  		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）、效果：
  					正常执行：前置通知-》目标方法-》返回通知-》后置通知
  					出现异常：前置通知-》目标方法-》异常通知-》后置通知