一文搞懂AOP

作者: 爱撒谎的男孩 | 来源:发表于2019-07-05 22:15 被阅读0次

一文搞懂AOP
一文搞懂Android账户系统的使用方式
线程、多线程和线程池，看完这些你就能全部搞懂了
AWS Region vs VPC vs Subnet vs A
一文搞懂液压蓄能器的工作原理，作用和使用方法
5. Batch normalization 与 Layer N
一问搞懂 Flink checkpoint snapshot全过
Android JetPack源码分析技巧
Spring AOP 增强框架 Nepxion Matrix 详
Android JetPack LiveData源码分析

简介

面向切面编程，是面向对象编程的重要组成部分，在不改变业务逻辑功能的基础上，对横切逻辑进行扩展

添加依赖

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

通知

@Before（前置通知）：在业务方法执行之前调用
@After（后置通知）：在方法之后执行
@AfterReturning(正常返回通知)：在方法之后执行，只有在业务方法没有出现异常的时候才会执行
@AfterThrowing(异常通知) ：在方法之后执行，只有在业务方法出现异常的时候才会执行
@Around （环绕通知）：在业务方法执行之前和之后执行

连接点

业务层的所有方法，叫做连接点
业务类中可以被增强的方法都叫做连接点

切点

能切入切面逻辑的方法，叫做切点
实际被增强的方法叫做切入点 ，其他的那些没有被增强的方法(连接点)不是切点

切面

定义了增强方法的类就叫做切面

实现

在配置类上开启切面，使用@EnableAspectJAutoProxy

@Configuration
@ComponentScan(value = {"cn.tedu.demo"})
@EnableAsync
@EnableAspectJAutoProxy
public class FirstConfig {}

使用五个不同的通知完成切入：

/**
 * 切面，使用@Aspect标注
 */
@Component
@Aspect
public class CustomAspect {

    /**
     * 使用@PointCut定义切入点
     */
    @Pointcut(value = "execution(* cn.tedu.demo.aspect.AspectInvok.invok(..))")
    public void pointCut(){}

    /**
     * 前置通知，在指定方法之前执行
     * @param point JoinPoint对象，可以获取切点的各种属性，比如入参的参数等
     */
    @Before(value = "pointCut()")
    public void before(JoinPoint point){
        //获取入参的参数的值
        Object[] args = point.getArgs();
        System.out.println(Arrays.asList(args));
        //获取MethodSignature，其中可以获取切点的各种属性，比如方法返回类型，参数等等
        MethodSignature signature = (MethodSignature) point.getSignature();
        String[] parameterNames = signature.getParameterNames();
        System.out.println(Arrays.asList(parameterNames));
        System.out.println("在方法之前执行");
    }

    /**
     * 在切点之后执行
     * @param point JoinPoint对象
     */
    @After(value = "pointCut()",argNames = "point")
    public void after(JoinPoint point){
        System.out.println("在方法之后执行");
    }

    /**
     * 在方法前后都会执行
     * @param point
     */
    @Around(value = "pointCut()")
    public void around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("前置执行");
        //执行方法，可以获取返回值，否则方法将不会执行
        Object result = point.proceed(point.getArgs());
        System.out.println("后置执行，执行的结果=="+result);
    }

    /**
     * 正常返回通知，
     * @param point Joinpoint对象
     * @param result 方法执行返回的结果，需要和@AfterReturning注解中returning中的属性值相同，否则不能自动装配
     */
    @AfterReturning(value = "pointCut()",returning = "result")
    public void afterReturning(JoinPoint point,Object result){
        System.out.println("正常返回执行，执行的结果为："+result);
    }

    /**
     * 异常返回执行，程序出现异常了才会执行
     * @param point
     * @param ex 切入点执行抛出的异常，需要和@AfterThrowing注解的throwing值相同，否则不能完成自动装配
     */
    @AfterThrowing(value = "pointCut()",throwing = "ex")
    public void afterThrowing(JoinPoint point,Exception ex){
        System.out.println("异常返回执行，执行的异常为："+ex);
    }
}

注解的实现

详细请看我的上一篇博客
定义一个注解，如下：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {
    String name() default "陈加兵";
    int age() default 22;
}

定义一个切面，使用注解如下：

@Component
@Aspect
public class CustomAspect {

    /**
     * 使用@PointCut定义切入点
     */
    @Pointcut(value = "@annotation(cn.tedu.demo.aspect.MyAnnotation)")
    public void pointCut(){}

    /**
     * 前置通知，在指定方法之前执行
     * @param point JoinPoint对象，可以获取切点的各种属性，比如入参的参数等
     */
    @Before(value = "pointCut()")
    public void before(JoinPoint point){
        //获取MethodSignature，其中可以获取切点的各种属性，比如方法返回类型，参数等等
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        //获取方法上指定的注解
        MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
        System.out.println("name="+myAnnotation.name());
        System.out.println("在方法之前执行");
    }
}

源码解析

@EnableAspectJAutoProxy

从@EnableAspectJAutoProxy该注解中可以看出使用了@Import(AspectJAutoProxyRegistrar.class)，因此实际作用的类就是AspectJAutoProxyRegistrar，因此我们必须跟进源码去看。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

AspectJAutoProxyRegistrar

该类实现ImportBeanDefinitionRegistrar【向容器中注入Bean】。
该类的主要作用就是向ioc容器中注入AnnotationAutoProxyCreator。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    /**
    * 向容器中注入AnnotationAutoProxyCreator
    */
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //调用方法注册AnnotationAutoProxyCreator
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        //获取@EnableAspectJAutoProxy注解中两个属性的值
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        //判断注解属性的值
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

}

AnnotationAutoProxyCreator【创建代理】

概念

advisor（增强器）：实现Advisor接口，简单的说一个advisor存储的就是被五个通知的标注的方法的信息。
advisedBeans：Map<Object, Boolean>类型，key是Bean，value存储的是这个Bean是否需要被增强器（通知方法）增强

分析

@EnableAspectJAutoProxy注解的主要作用就是向容器中注入AnnotationAutoProxyCreator，ID为org.springframework.aop.config.internalAutoProxyCreator，因此切面的关键类就是这个，我们看看继承关系图，如下：

[图片上传失败...(image-e8798a-1562336107568)]

从继承关系中可以看到该类及其父类实现了两个重要的接口，如下：
- InstantiationAwareBeanPostProcessor：spring的后置处理器，在实例化前后，初始化前后执行
- BeanFactoryAware：自动注入BeanFactory
通过上面的分析可以知道，AOP的主要功能必定是在AnnotationAutoProxyCreator这个Bean的初始化和实例化前后执行逻辑，无非就是上面两个接口定义的方法，我们可以在对应的方法中打断点跟踪代码。

代码跟踪

刷新容器种执行registerBeanPostProcessors(beanFactory)方法将全部的后置处理器注入到容器中，在其中执行执行后续的setBeanFactory的方法

根据Bean的生命周期我们可以判断最新执行的一定是实现Aware方法的setBeanFactory方法【在invokeAwareMethods()方法中执行】，实际执行也是符合我们的猜想，第一个执行的方法就是org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#setBeanFactory
- 创建AspectJAdvisorFactory：顾名思义，当然是从标注@Aspect的类中创建增强器【切面增强的方法】
- 创建BeanFactoryAspectJAdvisorsBuilder：简单的说就是创建增强器的辅助类，用来构造增强器

@Override
  public void setBeanFactory(BeanFactory beanFactory) {
        //调用父类的方法
      super.setBeanFactory(beanFactory);
      if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
          throw new IllegalArgumentException(
                  "AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
      }
        //实际执行的是initBeanFactory
      initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
  }

/*******************************initBeanFactory**************************/
  @Override
  protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
      super.initBeanFactory(beanFactory);
        //创建切面增强器工厂
      if (this.aspectJAdvisorFactory == null) {
          this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
      }
        //创建切面增强生成器
      this.aspectJAdvisorsBuilder =
              new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
  }

刷新容器方法中执行finishBeanFactoryInitialization(beanFactory)【实例化剩余的单例Bean】
- getBean()--->doGetBean--->createBean，在createBean方法中执行Object bean = resolveBeforeInstantiation(beanName, mbdToUse);【在实例化之前给一个机会返回一个代理】
  - 内部执行bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
    - 内部循环遍历后置处理器，判断类型为InstantiationAwareBeanPostProcessor，执行postProcessBeforeInstantiation（）方法【在实例化之前调用，接口定义】。
      - 此时执行到AbstractAutoProxyCreator#postProcessBeforeInstantiation，源码如下：
        
        这个方法的主要作用就是查找切面类和已经有了TargetSource的类，这些类都是不需要增强的，设置adviseBean的value为false，后续就不需要创建代理对象了
```
/**
* 在实例化之前执行逻辑，如果返回不为null，后续的属性赋值等操作将不会执行
*  主要的作用
*/
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        //获取cacheKey，主要是和FactoryBean对象区别
        Object cacheKey = getCacheKey(beanClass, beanName);
        //beanName为空，或者targetSourcedBeans不包含当前Bean
        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
                //如果需要增强的Bean已经包含了当前Bean，后续流程不需要执行，返回null即可
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            /**isInfrastructureClass(beanClass)：【如果当前Bean是基础的类【实现了Advice、Pointcut、Advisor、AopInfrastructureBean】并且满足this.aspectJAdvisorFactory不为null&&当前类被@Aspect注解标注了】
            *shouldSkip(beanClass, beanName)：
            *       ①获取所有的候选的增强器【List<Advisor> candidateAdvisors = findCandidateAdvisors();】
            *       ②循环候选增强器，判断类型是否是AspectJPointcutAdvisor
            */
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                //如果满足条件，那么表示该类是一个切面，不是需要增强的Bean，设置value为false
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        //获取自定义的TargetSource
        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
            //如果存在，那么可以直接创建代理对象
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }
```
      - 代码继续执行，发现postProcessProperties、postProcessBeforeInitialization、postProcessBeforeInitialization都是默认的实现，这里跳过。
      - 真正创建代理对象的是在postProcessAfterInitialization中，逻辑如下：
        
        ①判断bean是否为null和earlyProxyReferences中是否存在当前的Bean
        
        ②如果满足条件，调用wrapIfNecessary(bean, beanName, cacheKey)方法，封装Bean，其实就是创建代理对象
        
        ③进入wrapIfNecessary方法
        
        ①做一些判断，包括是否是targetSourcedBeans是否包含，是否是基础类，是否应该跳过，是否adviseBean中的value为false【不需要增强的Bean】，满足以上条件的都直接返回bean，不需要创建代理
        
        ②调用方法获取能够作用于当前Bean的增强器（通知方法集合）封装在specificInterceptors，代码跟进，最重要的实现是在org.springframework.aop.support.AopUtils.canApply(org.springframework.aop.Advisor, java.lang.Class<?>, boolean)这个方法中，大致的思想就是
        
        ③判断specificInterceptors是否为null，如果为空，表示当前Bean不需要增强，设置adviseBean的值为false，反之需要增强，此时就需要创建代理了，此时主要调用的是Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))
        
        ④ 进入createProxy方法
        
        ① 创建ProxyFactory，主要作用就是创建代理的工厂，其中封装了Advisor，targetSource，getProxy()【创建代理】方法等
        
        ② 判断是否应该直接代理目标类【if (!proxyFactory.isProxyTargetClass())】
        
        ③ 调用evaluateProxyInterfaces(beanClass, proxyFactory);方法，主要的作用就是检查当前Bean实现的接口是否符合要求能够创建代理对象【不能是InitializingBean，DisposableBean,Closeable,AutoCloseable等接口】，如果满足直接设置到ProxyFactory中，否则设置proxyTargetClass=true【直接代理目标类targetSource】
        
        ④ 调用Advisor[] advisors = buildAdvisors(beanName, specificInterceptors)方法，将公共的拦截器和适配的拦截器specificInterceptors一起返回
        
        ① 根据指定的this.interceptorNames拦截器名称从容器中获取Bean，将其解析成commonInterceptors
        
        ② 遍历commonInterceptors和specificInterceptors将其封装成Advisor数组返回
        
        ⑤ 将advisor和targetSource添加到ProxyFactory中
        
        ⑥ 调用proxyFactory.getProxy(getProxyClassLoader())方法，获取代理对象
        
        ① 最终调用的是org.springframework.aop.framework.DefaultAopProxyFactory.createAopProxy的方法创建代理对象，是AopProxyFactory默认实现类中的方法，具体逻辑如下：
        
        如果targetClass是接口或者继承Proxy使用JDK的动态代理，否则使用Cglib代理
        
        ⑤ 将创建的代理对象proxy存放在proxyTypes中，返回proxy
        
        ⑥ 至此代理对象创建完成

代理执行

上面解释了代理对象的创建流程，下面就开始真正的执行和增强的流程了，需要了解到五种通知类型在什么时候执行，执行的顺序是什么？
未完待续。。。。。

一文搞懂AOP
简介面向切面编程，是面向对象编程的重要组成部分，在不改变业务逻辑功能的基础上，对横切逻辑进行扩展添加依赖通知...
一文搞懂Android账户系统的使用方式
一文搞懂Android账户系统的使用方式简介概述实战环境布置基本使用（注册、登录和退出）注册登录退出附录一文搞懂...
线程、多线程和线程池，看完这些你就能全部搞懂了
摘要：一文带你搞懂线程、多线程和线程池。本文分享自华为云社区《一文搞懂线程与线程池[https://bbs.hu...
AWS Region vs VPC vs Subnet vs A
Reference: 一文搞懂AWS Region, VPC, VPC endpoint，AZ, Subnet 基...
一文搞懂液压蓄能器的工作原理，作用和使用方法
一文搞懂液压蓄能器的工作原理，作用和使用方法
5. Batch normalization 与 Layer N
本文为转载，原文链接: 一文搞懂Batch Normalization,Layer/Instance/Group ...
一问搞懂 Flink checkpoint snapshot全过
前言前面我们讲解了一文搞懂 Flink 处理 Barrier 全过程和一文搞定 Flink Checkpo...
Android JetPack源码分析技巧
本文从《一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewModel与...
Spring AOP 增强框架 Nepxion Matrix 详
文章来源公众号:方志朋在《深入聊一聊 Spring AOP 实现机制》一文中，介绍了 Spring AOP 的多种...
Android JetPack LiveData源码分析
本文从本人的《一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewMod...