关于jdk & cglib 动态代理及查看生成的 class, 可参考
https://www.jianshu.com/p/193150c42942

1.动态代理模式

2.Spring-AOP

概述

AOP(Aspect-Oriented Programming) 面向切面编程。
Spring Aop 在 Spring框架中的地位举足轻重，主要用于实现事务、缓存、安全等功能。

Spring AOP构建在动态代理基础之上，因此，Spring对AOP的支持局限于方法拦截。

AOP相关术语

#AOP相关术语
1.连接点(Join point)
连接点是在应用执行过程中能够插入切面的一个点。
表示需要在程序中插入横切关注点的扩展点，
连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，
Spring只支持方法执行连接点，在AOP中表示为“在哪里干”；

2.切点(Pointcut)
一个切面并不需要通知应用的所有连接点，切点有助于缩小切面所通知的连接点范围。
如果说通知定义了切面的“什么”和“何时”的话，那么切点就定义了“何处”。
因此，切点其实就是定义了需要执行在哪些连接点上执行通知。
如下文代码中的@Pointcut(value = "@within(LogInOut) || @annotation(LogInOut)").

3.切面(Aspect)
切面是通知和切点的结合。
通知和切点共同定义了切面的全部内容——它是什么，在何时和在何处完成其功能。
如下文代码中的类LogAspect.

4.引介增强（inter-type declaration）：
引介增强是一个比较特殊的增强，它不是在目标方法周围织入增强，
而是为目标类创建新的方法或属性，所以引介增强的连接点是类级别的，而非方法级别的，
Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“干什么（引入什么）”

5.织入(Weaving)
织入是把切面应用到目标对象并创建新的代理对象的过程。
切面在指定的连接点被织入到目标对象中。
在目标对象的生命周期中有很多个点可以进行织入:
>> 编译期：
切面在目标类编译时被织入。这种方式需要特殊的编译器。
AspectJ的织入编译器就是以这种方式织入切面的。
>> 类加载期：
切面在目标类加载到JVM时被织入。
这种方式需要特殊的类加载器，它可以在目标类被引入应用之前增强该目标类的字节码。
AspectJ 5的加载时织入就支持这种方式织入切面。
>> 运行期：
切面在应用运行的某个时刻被织入。
一般情况下，在织入切面时，AOP容器会为目标对象动态的创建一个代理对象。
Spring AOP就是以这种方式织入切面的。

6.通知/增强(Advice)
切面的工作被称为通知。通知定义了切面是什么以及何时使用。
除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。
五种通知类型见下文。
如下文代码中的@Around, @Before等注解.

Spring-AOP所支持的AspectJ切点指示器.png

2.1 核心类库

#Spring Aop中一些核心类，大致分为三类：
advisorCreator: 继承 spring ioc的扩展接口 beanPostProcessor，主要用来扫描获取 advisor。
advisor: 顾问的意思，封装了spring aop中的切点和通知。
advice: 通知，也就是aop中增强的方法。

2.1.1 AbstractAutoProxyCreator

1.AbstractAutoProxyCreator：
Spring 为Spring AOP 模块暴露的可扩展抽象类，也是 AOP 中最核心的抽象类。
Nepxion Matrix 框架便是基于此类对AOP进行扩展和增强。

2.BeanNameAutoProxyCreator：
根据指定名称创建代理对象(连接池框架druid也基于此类做了扩展).
通过设置 advisor，可以对指定的 beanName 进行代理。支持模糊匹配。

3.AbstractAdvisorAutoProxyCreator：
功能比较强大，默认扫描所有Advisor的实现类。
相对于根据Bean名称匹配，该类更加灵活。
动态的匹配每一个类，判断是否可以被代理，并寻找合适的增强类，以及生成代理类。

4.DefaultAdvisorAutoProxyCreator：
AbstractAdvisorAutoProxyCreator的默认实现类。
可以单独使用，在框架中使用AOP，尽量不要手动创建此对象。

5.AspectJAwareAdvisorAutoProxyCreator：
Aspectj的实现方式，也是Spring Aop中最常用的实现方式，
如果用注解方式，则用其子类AnnotationAwareAspectJAutoProxyCreator。

6.AnnotationAwareAspectJAutoProxyCreator：
目前最常用的AOP使用方式。
spring aop 开启注解方式之后，该类会扫描所有@Aspect()注释的类，生成对应的adviosr。
目前SpringBoot框架中默认支持的方式，自动配置。

AbstractAutoProxyCreator类图.png

2.1.2 PointcutAdvisor

1.StaticMethodMatcherPointcut：
静态方法切面，抽象类。
定义了一个classFilter，通过重写getClassFilter()方法来指定切面规则。
另外实现了StaticMethodMatcher接口，通过重写matches来指定方法匹配规则。

2.StaticMethodMatcherPointcutAdvisor：
静态方法匹配切面顾问，同未抽象类，扩展了切面排序方法。

3.NameMatchMethodPointcut：
名称匹配切面，通过指定方法集合变量mappedNames，模糊匹配。

4.NameMatchMethodPointcutAdvisor：
方法名称切面顾问，内部封装了NameMatchMethodPointcut，
通过设置方法名称模糊匹配规则和通知来实现切面功能。

5.RegexpMethodPointcutAdvisor：
正则表达式切面顾问，可设置多个正则表达式规则，通过内部封装的
JdkRegexpMethodPointcut解析正则表达式。

6.DefaultPointcutAdvisor：
默认切面顾问，比较灵活。可自由组合切面和通知。

7.InstantiationModelAwarePointcutAdvisorImpl：
springboot自动装配的顾问类型，也是最常用的一种顾问实现。
在注解实现的切面中，所有@Aspect类，都会被解析成该对象。

PointcutAdvisor.png

2.1.3 Advice

1.AspectJMethodBeforeAdvice：
前置通知, AspectJ中 before 属性对应的通知(@Before标注的方法会被解析成该通知), 在切面方法执行之前执行。
2.AspectJAfterAdvice：
后置通知, AspectJ中 after 属性对应的通知(@After 标注的方法会被解析成该通知), 不论是否异常都会执行。
注意：该通知与AspectJMethodBeforeAdvice对应。
3.AspectJAroundAdvice：
环绕通知, AspectJ中 around 属性对应的通知(@Around标注的方法会被解析成该通知), 在切面方法执行前后执行。
4.AspectJAfterReturningAdvice：
返回通知, AspectJ中 afterReturning 属性对应的通知(@AfterReturning 标注的方法会被解析成该通知), 
在切面方法执行之后执行，如果有异常，则不执行。
5.AspectJAfterThrowingAdvice:
返回异常通知, @AfterThrowing 标注的方法会被解析成该通知, 发生异常时执行.

#几种通知的执行顺序:
1.正常情况 @Around @Before 目标方法 @Around @After @AfterReturning;
2.异常情况 @Around @Before 目标方法 @After @AfterThrowing;

Advice.png

2.2 示例

2.2.1 借助Spring-AOP & Aspect 自定义注解, 实现日志拦截

package com.zy.eureka.proxy.aop;

import java.lang.annotation.*;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface LogInOut {
}

package com.zy.eureka.proxy.aop;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

@Aspect
@Slf4j
@Component
public class LogAspect {

    @Pointcut(value = "@within(LogInOut) || @annotation(LogInOut)")
    public void pointCut01(){}

    @Around(value = "pointCut01()")
    public Object parseLogInOutAnnotation(ProceedingJoinPoint point) throws Throwable {
        Object[] args = point.getArgs();
        MethodSignature signature = (MethodSignature) point.getSignature();
        String className = signature.getDeclaringType().getSimpleName();
        String methodName = signature.getName();
        log.info("[input]{}#{}({})", className, methodName, JSON.toJSONString(args));
        Object result = point.proceed();
        log.info("[output]{}#{}({})", className, methodName, JSON.toJSONString(result));
        return result;
    }

    @Before(value = "pointCut01()")
    public void before(JoinPoint point) {
        System.out.println("do sth before execute method: " + point.getSignature().getName());
    }

    @After(value = "pointCut01()")
    public void after(JoinPoint point) {
        System.out.println("do sth after execute method: " + point.getSignature().getName());
    }

    @AfterReturning(value = "pointCut01()", returning = "result")
    public void afterReturning(JoinPoint point, Object result) {
        System.out.println("do sth afterReturning execute method: " + point.getSignature().getName() + ". result is " + result);
    }

    @AfterThrowing(value = "pointCut01()", throwing = "ex")
    public void afterThrowing(JoinPoint point, Throwable ex) {
        System.out.println("do sth afterThrowing execute method: " + point.getSignature().getName() + ". error is " + ex.getMessage());
    }

}

// 关于controller层, 自行定义即可测试
// 正常情形时, 控制台输出为: 
[input]MyController#helloWorld([{"age":20,"name":"tommy"}])
do sth before execute method: helloWorld
[output]MyController#helloWorld({"code":"200","data":"success","msg":"hello","success":true})
do sth after execute method: helloWorld
do sth afterReturning execute method: helloWorld. result is ResponseVO(success=true, code=200, msg=hello, data=success)

// 发生异常时, 控制台输出为: 
[input]MyController#helloWorld([{"age":20,"name":"tommy"}])
do sth before execute method: helloWorld
do sth after execute method: helloWorld
do sth afterThrowing execute method: helloWorld. error is ...............

项目启动中-->解析@Aspect-01.png 项目启动中-->解析@Aspect-02.png

3.源码解析(基于spring-boot-2.1.4, 即spring5.1.6)

大致主要分为三个步骤：
1： 创建AnnotationAwareAspectJAutoProxyCreator对象
2： 扫描容器中的切面，创建PointcutAdvisor对象
3： 生成代理类

3.1 创建AnnotationAwareAspectJAutoProxyCreator对象

启动时, 自动装配的过程见:
https://www.jianshu.com/p/5d5890645165
>> step5: invokeBeanFactoryPostProcessors

step1:EnableAspectJAutoProxy注解等存在, 配置消息被扫描, 默认加载Cglib配置.png step2: 启动时扫描@Import注解-寻找AspectJAutoProxyRegistrar.png step3-1: AnnotationAwareAspectJAutoProxyCreator注册到beanDefinitionMap.png step3-2: AnnotationAwareAspectJAutoProxyCreator注册到beanDefinitionMap.png step4: AnnotationAwareAspectJAutoProxyCreator实例化前调用postProcessBeforeInstantiation方法.png

step4: 
AnnotationAwareAspectJAutoProxyCreator实例化前调用postProcessBeforeInstantiation方法

AnnotationAwareAspectJAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口,
在其实例化前, 会调用其postProcessBeforeInstantiation方法,
而其postProcessBeforeInstantiation方法由其父类AbstractAutoProxyCreator实现,
所以一旦进入postProcessBeforeInstantiation方法, 其流程为:

--> AbstractAutoProxyCreator#postProcessBeforeInstantiation
    // 如果 beanName 不为空, 判断其是否是 FactoryBean, 若是, cacheKey = & + beanName; 否则, cacheKey = beanName
    // 如果 beanName 为空, cacheKey = beanClass
    // advisedBeans 用于存储不可代理的bean(cacheKey)，如果包含直接返回
    --> AbstractAutoProxyCreator#getCacheKey
    // 判断当前bean(cacheKey)是否可以被代理，然后存入 advisedBeans
    // 不可被代理的: Advice, Pointcut, Advisor, AopInfrastructureBean
    --> AbstractAutoProxyCreator#isInfrastructureClass
    // 判断是否应该跳过
    --> AspectJAwareAdvisorAutoProxyCreator#shouldSkip
        --> AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors
            --> AbstractAdvisorAutoProxyCreator#findCandidateAdvisors
                // 从 beanfactory 中获取所有的 Advisor
                --> BeanFactoryAdvisorRetrievalHelper#findAdvisorBeans
            // 寻找 beanfactory 中所有 @Aspect 注解标注的类, 并为每一个 @Aspect 创建 Advisor, 返回值是 List<Advisor>
            --> BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors
                这个 buildAspectJAdvisors 方法分析, 详见下文
        --> AbstractAutoProxyCreator#shouldSkip

BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors

/**
 * 在当前BeanFactory中查找AspectJ-annotated的注解信息，并返回增强集合
 */
public List<Advisor> buildAspectJAdvisors() {
    List<String> aspectNames = this.aspectBeanNames;
    // 1、提取增强
    if (aspectNames == null) {
        synchronized (this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                List<Advisor> advisors = new ArrayList<>();
                aspectNames = new ArrayList<>();
                // 1.1、获取容器中的所有bean
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                // 1.2、循环所有的bean，并从切面类上提取增强
                for (String beanName : beanNames) {
                    // 判断该beanName是否符合条件
                    // 如果配置文件指定了<aop:include/>属性，那么只有符合表达式条件的切面类的增强才会被提取
                    // 例如：配置<aop:include name="dogAspect"></aop:include>, 那么只有dogAspect切面类的增强才会被提取
                    // 最终调用: AnnotationAwareAspectJAutoProxyCreator#isEligibleAspectBean
                    if (!isEligibleBean(beanName)) {
                        continue;
                    }
                    // We must be careful not to instantiate beans eagerly as in this case they
                    // would be cached by the Spring container but would not have been weaved.
                    // 获取beanType类型
                    Class<?> beanType = this.beanFactory.getType(beanName);
                    if (beanType == null) {
                        continue;
                    }
                    // 如果beanType是一个切面类: 有 @Aspect 注解, 并且这个类中所有的属性，不能是“ajc$”开头
                    if (this.advisorFactory.isAspect(beanType)) {
                        aspectNames.add(beanName);
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
                        /**
                         * 切面实例化模型简介
                         *
                         * singleton: 即切面只会有一个实例；
                         * perthis  : 每个切入点表达式匹配的连接点对应的AOP对象都会创建一个新切面实例；
                         *            使用@Aspect("perthis(切入点表达式)")指定切入点表达式；多实例
                         *            例如: @Aspect("perthis(this(com.lyc.cn.v2.day04.aspectj.Dog))")
                         * pertarget: 每个切入点表达式匹配的连接点对应的目标对象都会创建一个新的切面实例；
                         *            使用@Aspect("pertarget(切入点表达式)")指定切入点表达式；多实例
                         *            例如:
                         *
                         * 默认是singleton实例化模型，Schema风格只支持singleton实例化模型，而@AspectJ风格支持这三种实例化模型。
                         */
                        // singleton实例化模型处理
                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                            MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                            // 获取所有的增强方法，并缓存
                            List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                            if (this.beanFactory.isSingleton(beanName)) {
                                this.advisorsCache.put(beanName, classAdvisors);
                            }
                            else {
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            advisors.addAll(classAdvisors);
                        }
                        // perthis或pertarget实例化模型处理(多实例时)
                        else {
                            /**
                             * 注意：当使用perthis或pertarget属性时，切面类不能是单例bean，否则会抛出下面的异常
                             * 例如：<bean name="dogAspect" class="com.zy.aspectj.LogAspect" scope="singleton"/>
                             * 则会报错，应该为
                             * <bean name="dogAspect" class="com.zy.aspectj.LogAspect" scope="prototype"/>
                             */
                            if (this.beanFactory.isSingleton(beanName)) {
                                ... 这里抛异常 ...
                            }
                            MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                            this.aspectFactoryCache.put(beanName, factory);
                            advisors.addAll(this.advisorFactory.getAdvisors(factory));
                        }
                    }
                }
                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }
    }

    // 2、返回从缓存中获取提取到的增强方法
    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    List<Advisor> advisors = new ArrayList<>();
    for (String aspectName : aspectNames) {
        List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        }
        else {
            MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }
    return advisors;
}

ReflectiveAspectJAdvisorFactory#getAdvisors

public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    // 1、预处理工作，包括获取切面类，名称，验证等
    Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
    validate(aspectClass);
    // 我们需要用一个装饰器包装MetadataAwareAspectInstanceFactory，这样它只会实例化一次。
    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
    // 2、提取增强
    // 2.1、获取切面类的所有方法，循环判断提取合适的切入点，并创建增强
    List<Advisor> advisors = new ArrayList<>();
    // getAdvisorMethods 方法处理 class 中加了 5 种注解的方法, 并排序处理
    for (Method method : getAdvisorMethods(aspectClass)) {
        // 获取增强
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }
    // If it's a per target aspect, emit the dummy instantiating aspect.
    // 2.2、处理perthis和pertarget切面类
    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        // 创建SyntheticInstantiationAdvisor实例
        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        // 将SyntheticInstantiationAdvisor实例加入到advisors集合首位，注意：不是替换
        advisors.add(0, instantiationAdvisor);
    }
    // Find introduction fields.
    // 2.3、处理引入，获取所有的引入并循环创建DeclareParentsAdvisor
    // 获取 @DeclareParents 注解修饰的属性（并不常用）
    for (Field field : aspectClass.getDeclaredFields()) {
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }
    return advisors;
}

ReflectiveAspectJAdvisorFactory#getAdvisor 获取增强

public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
        int declarationOrderInAspect, String aspectName) {
    // 1、验证
    validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
    // 2、提取切入点
    AspectJExpressionPointcut expressionPointcut = getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    if (expressionPointcut == null) {
        return null;
    }
    // 3、创建增强 InstantiationModelAwarePointcutAdvisorImpl (这个实现类中有一个属性即为 Advice)
    return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

ReflectiveAspectJAdvisorFactory#getAdvisor 提取切入点

private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
    // 1、从候选切入点上找出增强表达式: 这里只返回一个切点表达式, 找到即止
    AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        return null;
    }
    // 2、创建AspectJExpressionPointcut对象
    AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
    ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
    if (this.beanFactory != null) {
        ajexp.setBeanFactory(this.beanFactory);
    }
    return ajexp;
}

创建 Advisor

public InstantiationModelAwarePointcutAdvisorImpl(
            AspectJExpressionPointcut declaredPointcut,
            Method aspectJAdviceMethod,
            AspectJAdvisorFactory aspectJAdvisorFactory,
            MetadataAwareAspectInstanceFactory aspectInstanceFactory,
            int declarationOrder,
            String aspectName) {

    this.declaredPointcut = declaredPointcut;
    this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
    this.methodName = aspectJAdviceMethod.getName();
    this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
    this.aspectJAdviceMethod = aspectJAdviceMethod;
    this.aspectJAdvisorFactory = aspectJAdvisorFactory;
    this.aspectInstanceFactory = aspectInstanceFactory;
    this.declarationOrder = declarationOrder;
    this.aspectName = aspectName;

    // 1、延迟初始化
    // 在Spring AOP中，切面类的实例只有一个，比如前面我们一直使用的MyAspect类，
    // 假设我们使用的切面类需要具有某种状态，以适用某些特殊情况的使用，比如多线程环境，此时单例的切面类就不符合我们的要求了。
    // 在Spring AOP中，切面类默认都是单例的，但其还支持另外两种多例的切面实例的切面，即perthis和pertarget，
    // 需要注意的是perthis和pertarget都是使用在切面类的@Aspect注解中的。
    // 这里perthis和pertarget表达式中都是指定一个切面表达式，其语义与前面讲解的this和target非常的相似，
    // perthis表示如果某个类的代理类符合其指定的切面表达式，那么就会为每个符合条件的目标类都声明一个切面实例；
    // pertarget表示如果某个目标类符合其指定的切面表达式，那么就会为每个符合条件的类声明一个切面实例。
    // 从上面的语义可以看出，perthis和pertarget的含义是非常相似的。如下是perthis和pertarget的使用语法：
    // perthis(pointcut-expression)
    // pertarget(pointcut-expression)
    if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        // Static part of the pointcut is a lazy type.
        Pointcut preInstantiationPointcut = Pointcuts.union(aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);

        // Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
        // If it's not a dynamic pointcut, it may be optimized out
        // by the Spring AOP infrastructure after the first evaluation.
        this.pointcut = new PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
        this.lazy = true;
    }
    // 2、立刻初始化
    else {
        // A singleton aspect.
        this.pointcut = this.declaredPointcut;
        this.lazy = false;
        // 初始化增强
        this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
    }
}

InstantiationModelAwarePointcutAdvisorImpl#instantiateAdvice 实例化单例的 Advice
ReflectiveAspectJAdvisorFactory#getAdvice

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    // 1、获取增强之前的处理
    Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    validate(candidateAspectClass);
    AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        return null;
    }
    // If we get here, we know we have an AspectJ method.
    // Check that it's an AspectJ-annotated class
    if (!isAspect(candidateAspectClass)) {
        ... 抛异常 ...
    }
    // 2、针对各种不同的增强，做不同的处理
    AbstractAspectJAdvice springAdvice;
    switch (aspectJAnnotation.getAnnotationType()) {
        // 1、前置增强
        case AtBefore:
            springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        // 2、后置增强
        case AtAfter:
            springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        // 3、后置返回增强
        case AtAfterReturning:
            springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                springAdvice.setReturningName(afterReturningAnnotation.returning());
            }
            break;
        // 4、后置异常增强
        case AtAfterThrowing:
            springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
            }
            break;
        // 5、环绕增强
        case AtAround:
            springAdvice = new AspectJAroundAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        // 6、如果是Pointcut，则不做处理
        case AtPointcut:
            return null;
        // 7、未能满足case条件，抛出异常
        default:
            throw new UnsupportedOperationException("Unsupported advice type on method: " + candidateAdviceMethod);
    }

    // 3、获取增强方法之后，对增强方法进行配置
    springAdvice.setAspectName(aspectName);
    springAdvice.setDeclarationOrder(declarationOrder);
    String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
    if (argNames != null) {
        springAdvice.setArgumentNamesFromStringArray(argNames);
    }
    springAdvice.calculateArgumentBindings();
    return springAdvice;
}

step4实例化后, 创建BeanFactoryAdvisorRetrievalHelperAdapter对象.png

https://blog.csdn.net/woshilijiuyi/article/details/83934407 (Spring AOP, 部分解读有误)
https://www.jianshu.com/p/b45bf3befa25 (AOP)

参考资源
https://www.cnblogs.com/zhangxufeng/p/9160869.html (AOP核心参考, 切点表达式)

https://blog.csdn.net/luanlouis/article/details/24589193 (动态代理)
https://www.jianshu.com/p/efe1fea3e2f7 (反射机制)
https://blog.csdn.net/mbh12333/article/details/80255430 (几种通知)
https://www.cnblogs.com/sandea/p/11175834.html (Spring AOP)

https://www.jianshu.com/u/83d13e631c12 (Sprnig系列分析 ---> 核心参考)