《Spring 5.x源码解析之Spring AOP 注解驱动使用及其实现原理》

学好路更宽，钱多少加班。---- mercyblitz

一、前言

大家好，欢迎阅读《Spring 5.x源码解析》系列，本篇作为该系列的第二篇，重点介绍Spring AOP在注解驱动编程模式上的使用及其实现原理。文章内容基于小马哥讲 Spring AOP 编程思想以及Spring源码深度解析（第2版）。笔者多次阅读上述学习资料，形成个人关于Spring的知识总结，希望能帮助各位小伙伴！

二、本文概览

三、使用示例

在本节，我们详细介绍Spring AOP所支持的AspectJ注解使用，在目标方法拦截上介绍@Before、@After、@AfterReturning、@AfterThrowing、@Around、@DeclareParents以及在切入点表达式上介绍execution、within、target、this、args、@args、@target、@within、@annotation的使用

1、@Aspect

该注解的作用就是定义该类是一个切面，在Spring IoC容器会根据Aspect标记拿出该类，创建对应的Advisor，详细动作会在下节实现原理说。

2、AOP通知注解使用

Spring支持AspectJ拦截注解包括@Before、@After、@AfterReturning、@AfterThrowing、@Around，下面简单介绍下他们的作用以及使用方式:

• @Before: 该注解的作用是定义连接点的前置通知方法，在目标方法调用前执行
• @After: 该注解的作用是定义连接点的最终通知方法，在目标方法执行后执行(目标方法正常或异常情况均会执行)
• @AfterReturning: 该注解的作用是定义连接点的后置返回通知方法，在目标方法成功返回后执行
• @AfterThrowing: 该注解的作用是定义在连接点的后置异常返回通知方法，在目标方法执行异常后执行
• @Around: 环绕通知，可以在目标方法执行前后任意时机执行，目标的方法调用是方法内主动去调用，而上面四个注解是被动调用。

下面看下他们的使用示例:

• 切面以及通知定义

package com.markus.spring.aop.feature.blog.aspect;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;/*** @author: markus* @date: 2022/11/29 1:16 PM* @Description: 前置方法拦截* @Blog: http://markuszhang.com* It's my honor to share what I've learned with you!*/
@Aspect
public class AspectJAnnotationConfig {@Before(value = "target(com.markus.aop.overview.EchoService)")public void before() {System.out.println("这是前置通知");}@After(value = "target(com.markus.aop.overview.EchoService)")public void after() {System.out.println("这是方法最终通知");}@AfterReturning(value = "target(com.markus.aop.overview.EchoService)")public void afterReturning() {System.out.println("这是方法返回通知");}@AfterThrowing(value = "target(com.markus.aop.overview.EchoService)")public void afterThrowing() {System.out.println("这是方法异常通知");}@Around(value = "target(com.markus.aop.overview.EchoService)")public Object around(ProceedingJoinPoint pjp) throws Throwable {System.out.println("这是方法环绕前置通知");try {Object obj = pjp.proceed();System.out.println("这是方法环绕返回通知");return obj;} catch (Throwable e) {System.out.println("这是方法环绕异常通知");throw e;} finally {System.out.println("这是方法环绕最终通知");}}}

• 使用

package com.markus.spring.aop.feature.blog;import com.markus.aop.overview.DefaultEchoService;
import com.markus.aop.overview.EchoService;
import com.markus.spring.aop.feature.blog.aspect.AspectJAnnotationConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;/*** @author: markus* @date: 2022/11/29 1:20 PM* @Description: AspectJ注解使用示例* @Blog: http://markuszhang.com* It's my honor to share what I've learned with you!*/
@EnableAspectJAutoProxy
public class AspectJAnnotationDemo {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(AspectJAnnotationDemo.class, AspectJAnnotationConfig.class);context.refresh();EchoService echoService = context.getBean(EchoService.class);echoService.echo("Hello World!");context.close();}@Beanpublic EchoService echoService() {return new DefaultEchoService();}
}

• 控制台结果

// 方法正常执行
这是方法环绕前置通知
这是前置通知
[echo] Hello World!
这是方法环绕返回通知
这是方法环绕最终通知
这是方法最终通知
这是方法返回通知Process finished with exit code 0// 方法异常执行
这是方法环绕前置通知
这是前置通知
这是方法环绕异常通知
这是方法环绕最终通知
这是方法最终通知
这是方法异常通知
Exception in thread "main" java.lang.RuntimeException: 有一定几率异常at com.markus.aop.overview.DefaultEchoService.echo(DefaultEchoService.java:23)

3、Pointcut切入点表达式

在上面我们看到@Before等等注解内都会有一个value = “target(com.markus.aop.overview.EchoService)”，这个value内容是匹配目标方法的表达式，表达式类型有许多并且也可以通过@Pointcut注解来统一处理，@Before等通知注解引用这个Pointcut即可。下面来逐一介绍下表达式的种类以及其使用方法

• 第一种: execution(modifiers-pattern? ret-type-pattern declare-type-pattern.? name-pattern(param-pattern) throws-pattern?)
  • 其中带"?"的表示在表达式中可有可无的
  • modifiers-pattern 表示方法的访问类型
  • ret-type-pattern 表示方法的返回值类型
  • declare-type-pattern 表示方法所在类的类型
  • name-pattern 表示方法签名
  • param-pattern 表示参数的类型
  • throws-pattern 表示异常抛出的类型
• 第二种: within(package),对指定模块下的方法进行匹配
  • package 表示模块，可使用通配符
• 第三种: this(package.class),对指定类下的方法进行匹配
  • package.class 指向代理对象，不可以使用通配符
• 第四种: target(package.class),对指定类下的方法进行匹配
  • package.class 指向目标对象，不可以使用通配符
• 第五种: args(ParameterType,…),对指定参数类型的方法进行匹配
  • ParameterType 表示目标方法的参数类型
• 第六种: @target(package.class),执行方法所在的对象是否被目标注解定义
  • 执行方法的对象，不一定是定义方法的对象，属于运行时匹配，所以@target会将所有原始对象生成代理，所以慎用！
• 第七种: @within(package.class),定义方法所在的对象是否被目标注解匹配
  • 定义方法的对象，属于静态对象
• 第八种: @args(annotationType),目标方法的参数是否被目标注解定义
  • annotationType 注解类型，匹配目标方法的参数是否具备目标注解
• 第九种: @annotation(annotationType),目标方法是否被目标注解定义
  • annotationType 注解类型

上面介绍了各种表达式的定义以及作用，下面来介绍下他们的使用方法：

• 切面以及表达式定义:

 package com.markus.spring.aop.feature.blog.aspect;import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;/*** @author: markus* @date: 2022/12/1 1:27 PM* @Description: 横切点表达式使用演示* @Blog: http://markuszhang.com* It's my honor to share what I've learned with you!*/
@Aspect
public class AspectJPointcutExpressionConfig {// 表示 方法的访问类型为public 任意返回类型 任意类型的specialReferenceDemo方法 参数可有可无@Pointcut(value = "execution(public * *.specialReferenceDemo(..))")public void executionPointcut() {}// 表示 匹配在com.markus.spring.aop.feature.blog子模块下的方法@Pointcut(value = "within(com.markus.spring.aop.feature.blog.domain.*)")public void withinPointcut() {}// 表示 匹配目标对象是com.markus.spring.aop.feature.blog.domain.DefaultPointcutDemo下的方法@Pointcut(value = "target(com.markus.spring.aop.feature.blog.domain.DefaultPointcutDemo)")public void targetPointcut() {}// 表示 匹配代理对象是com.markus.spring.aop.feature.blog.domain.PointcutDemo下的方法@Pointcut(value = "this(com.markus.spring.aop.feature.blog.domain.PointcutDemo)")public void thisPointcut(){}// 表示 匹配的方法中参数是ArgsDemo类型@Pointcut(value = "args(com.markus.spring.aop.feature.blog.domain.ArgsDemo)")public void argsPointcut(){}// 表示 匹配被@EchoInterface定义的对象下的方法// 它是动态匹配的，会为所有目标对象生成代理，所以慎用！例如AOP动态代理通过cglib实现，遇到被final修饰的bean对象，就会抛出异常@Pointcut(value = "@target(com.markus.aop.overview.annotation.EchoInterface)")public void atTargetPointcut(){}// 表示 匹配被@EchoInterface定义的对象下的方法// 与@target不同，它是属于静态匹配，描述为定义方法的对象被@EchoInterface注释@Pointcut(value = "@within(com.markus.aop.overview.annotation.EchoInterface)")public void atWithinPointcut(){}// 表示 匹配参数所属的类型被@EchoInterface注释的所有方法@Pointcut(value = "@args(com.markus.aop.overview.annotation.EchoInterface)")public void atArgsPointcut(){}// 表示 匹配被@EchoInterface注释的所有方法@Pointcut(value = "@annotation(com.markus.aop.overview.annotation.EchoInterface)")public void atAnnotationPointcut(){}@Before("executionPointcut()")public void executionPointcutBefore() {System.out.println("this is execution pointcut");}@Before("withinPointcut()")public void withinPointcutBefore() {System.out.println("this is within pointcut");}@Before("targetPointcut()")public void targetPointcutBefore(){System.out.println("this is target pointcut");}@Before("thisPointcut()")public void thisPointcutBefore(){System.out.println("this.is this pointcut");}@Before("argsPointcut())")public void argsPointcutBefore(){System.out.println("this is args pointcut");}@Before("atTargetPointcut()")public void atTargetPointcutBefore(){System.out.println("this is @target pointcut");}@Before("atWithinPointcut()")public void atWithinPointcutBefore(){System.out.println("this is @within pointcut");}@Before("atArgsPointcut()")public void atArgsPointcutBefore(){System.out.println("this is @args pointcut");}@Before("atAnnotationPointcut()")public void atAnnotationPointBefore(){System.out.println("this is @annotation pointcut");}
}

• 客户端

package com.markus.spring.aop.feature.blog;import com.markus.spring.aop.feature.blog.aspect.AspectJPointcutExpressionConfig;
import com.markus.spring.aop.feature.blog.domain.ArgsDemo;
import com.markus.spring.aop.feature.blog.domain.DefaultPointcutDemo;
import com.markus.spring.aop.feature.blog.domain.PointcutDemo;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;/*** @author: markus* @date: 2022/12/1 10:24 PM* @Description: 横切点表达式使用示例* @Blog: http://markuszhang.com* It's my honor to share what I've learned with you!*/
@EnableAspectJAutoProxy
public class AspectJPointcutExpressionDemo {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(AspectJPointcutExpressionDemo.class, AspectJPointcutExpressionConfig.class);context.refresh();PointcutDemo pointcutDemo = context.getBean(PointcutDemo.class);ArgsDemo argsDemo = context.getBean(ArgsDemo.class);System.out.println("-----start-----");pointcutDemo.specialReferenceDemo(argsDemo);System.out.println("-----end-----");context.close();}@Beanpublic PointcutDemo pointcutDemo() {return new DefaultPointcutDemo();}@Beanpublic ArgsDemo argsDemo() {return new ArgsDemo("Hello World!");}
}

• 控制台

-----start-----
this is args pointcut
this is @annotation pointcut
this is @args pointcut
this is @target pointcut
this is @within pointcut
this is execution pointcut
this is target pointcut
this.is this pointcut
this is within pointcut
special reference demo content is 
-----end-----Process finished with exit code 0

4、@DeclareParents-接口增强

@DeclareParents可以声明在切面类里，可以起到对拦截器进行增强的作用。下面通过代码演示一下

• 切面类

@Aspect
public class AspectJDeclareParentsConfig {@DeclareParents(value = "com.markus.spring.aop.feature.blog.domain.DefaultPointcutDemo", defaultImpl = DefaultUsageTracked.class)private UsageTracked usageTracked;@Before("target(com.markus.spring.aop.feature.blog.domain.PointcutDemo) && this(usageTracked)")public void before(UsageTracked usageTracked){usageTracked.echoMethodInvokeCount();}
}

• 启动类

@EnableAspectJAutoProxy
public class AspectJDeclareParentsDemo {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(AspectJDeclareParentsDemo.class, AspectJDeclareParentsConfig.class);context.refresh();PointcutDemo pointcutDemo = context.getBean(PointcutDemo.class);pointcutDemo.commonDemo("Hello World!");context.close();}@Beanpublic PointcutDemo pointcutDemo() {return new DefaultPointcutDemo();}
}

• 控制台打印

1
common demo content is Hello World!Process finished with exit code 0

四、实现原理

1、时序图

注解驱动实现原理时序图流程可分为三部分来看:

• IoC容器启动过程AOP前期准备-注册AnnotationAwareAspectJAutoProxyCreator
• 用户获取指定的Spring Bean-为当前Bean创建代理对象
• 调用Bean的目标方法-采用动态代理，调用目标方法，在其过程中获取匹配的MethodInterceptor并依次调用实现对目标方法的拦截后，最终通过反射调用目标方法

2、关键代码

如上时序图，可以较为清晰的看到Spring是如何给IoC容器中Bean创建代理对象，并且通过代理对象的调用实现对目标方法的拦截。这里再介绍下内部的细节，内容如下:

• Spring是如何开启自动代理的？
• Spring是如何将用户定义的Advice构建为Advisor的？
• Spring是如何创建代理对象的？
• Spring是如何将advisor适配为MethodInterceptor并分配给匹配的方法上的？
• Spring AOP的五种advice执行的先后顺序是如何定义的？

a.Spring是如何开启自动代理的？

Spring通过@EnableAspectJAutoProxy开启AspectJ自动代理，主要是在加载BeanDefinition时动态注册AnnotationAwareAspectJAutoProxyCreator，使的Bean生命周期中创建Bean实例可以有被代理的机会。

• @EnableAspectJAutoProxy

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 重点在这，通过@Import导入具体的注册器类，在该类下注册相应的BeanDefinition 这也是使用@EnableXXX注解驱动的大致逻辑
@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}.* 可以通过该字段标注Spring是采用jdk动态代理还是CGLIB字节码提升创建代理* true 使用CGLIB* 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* 标识代理是否被可以被当前线程本地缓存 AopContext#setCurrentProxy(proxy)*/boolean exposeProxy() default false;}

• AspectJAutoProxyRegistrar

// 定义AspectJAutoProxyRegistrar 实现ImportBeanDefinitionRegistrar的registerBeanDefinitions方法，在加载BeanDefinition的时候注册自定义的BeanDefinition
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.*/@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {// 向BeanDefinitionRegistry中注册AnnotationAwareAspectJAutoProxyCreatorAopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);AnnotationAttributes enableAspectJAutoProxy =AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);if (enableAspectJAutoProxy != null) {// @EnableAspectJAutoProxy中的proxyTargetClass配置if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);}// @EnableAspectJAutoProxy中的exposeProxy配置if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);}}}}

• AopConfigUtils

@Nullable
// 在@EnableAspectJAutoProxy中cls指的是的AnnotationAwareAspectJAutoProxyCreator
private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");// 处理Spring中自动代理创建器的优先级问题 如果即将被注册的cls比IoC容器中已存在的自动代理创建器有冲突，则选择优先级最高的进行定义// 优先级从小到大: InfrastructureAdvisorAutoProxyCreator < AspectJAwareAdvisorAutoProxyCreator < AnnotationAwareAspectJAutoProxyCreatorif (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);if (!cls.getName().equals(apcDefinition.getBeanClassName())) {int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());int requiredPriority = findPriorityForClass(cls);if (currentPriority < requiredPriority) {apcDefinition.setBeanClassName(cls.getName());}}return null;}// 无优先级冲突，则创建该类的RootBeanDefinition并注册到BeanDefinitionRegistry中RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);beanDefinition.setSource(source);beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);return beanDefinition;
}

b.Spring是如何将用户定义的Advice构建为Advisor的？

讲述这个问题前，我们先了解下哪些内容可以被Spring认为成Advisor

• IoC容器中注册的Advisor Bean
• IoC容器中注册的Aspect Bean中的Advice method

第一个很好理解，Spring通过依赖查找找到IoC容器注册的Advisor相关Bean，将其加入到List集合中，那第二种Spring是如何进行转换的呢，我们下面来详细了解下

• AbstractAdvisorAutoProxyCreator

@Override
@Nullable
// Spring在给Bean创建代理对象时，会为该Bean查找所有的Advice和Advisor
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, @Nullable TargetSource targetSource) {// 查找所有符合条件的AdvisorList advisors = findEligibleAdvisors(beanClass, beanName);if (advisors.isEmpty()) {return DO_NOT_PROXY;}return advisors.toArray();
}
// 查找所有符合条件的Advisor
protected List findEligibleAdvisors(Class beanClass, String beanName) {// 查找所有的AdvisorList candidateAdvisors = findCandidateAdvisors();// 筛选出符合条件的AdvisorList eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);// 拓展Advisor，目前在AnnotationAwareAspectJAutoProxyCreator中拓展了此功能，在执行链中增加了ExposeInvocationInterceptor，用于感知目前进行的执行链执行的上下文。// ExposeInvocationInterceptor拦截器不需要用户感知，只有在AspectJ注解风格下 Spring才会使用extendAdvisors(eligibleAdvisors);if (!eligibleAdvisors.isEmpty()) {eligibleAdvisors = sortAdvisors(eligibleAdvisors);}return eligibleAdvisors;
}
// 查询候选的Advisor Bean，子类可以重写此方法来丰富Advisor来源
protected List findCandidateAdvisors() {Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");// 这里面就是通过BeanFactory依赖查找Advisor的相关Bean集合，不做赘述了return this.advisorRetrievalHelper.findAdvisorBeans();
}

• AnnotationAwareAspectJAutoProxyCreator

@Override
// 重写AbstractAdvisorAutoProxyCreator中的findCandidateAdvisors方法
protected List findCandidateAdvisors() {// Add all the Spring advisors found according to superclass rules.// 父类提供的查询规则List advisors = super.findCandidateAdvisors();// Build Advisors for all AspectJ aspects in the bean factory.// 基于AspectJ注解，搜寻其切面下的Advice方法 并转换为Advisorif (this.aspectJAdvisorsBuilder != null) {advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());}return advisors;
}

• BeanFactoryAspectJAdvisorBuilderAdapter

public List buildAspectJAdvisors() {// <1> 找到IoC容所有的Aspect Bean名称List aspectNames = this.aspectBeanNames;if (aspectNames == null) {synchronized (this) {aspectNames = this.aspectBeanNames;if (aspectNames == null) {List advisors = new ArrayList<>();aspectNames = new ArrayList<>();// 也是通过依赖查找，是查找到所有的Bean名称集合String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);for (String beanName : beanNames) {// 遍历所有的Bean名称，排除一些不符合条件的Beanif (!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.// 这里作者解释了，为什么采用类型查找，而不是实例查找Class beanType = this.beanFactory.getType(beanName);if (beanType == null) {continue;}// 通过AspectJAdvisorFactory判断当前类是否被@Aspect注释if (this.advisorFactory.isAspect(beanType)) {aspectNames.add(beanName);AspectMetadata amd = new AspectMetadata(beanType, beanName);if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {MetadataAwareAspectInstanceFactory factory =new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);// 获取该切面下的所有advisorList classAdvisors = this.advisorFactory.getAdvisors(factory);if (this.beanFactory.isSingleton(beanName)) {// 缓存切面下对应的advisorthis.advisorsCache.put(beanName, classAdvisors);}else {// 缓存切面下对应的实例工厂this.aspectFactoryCache.put(beanName, factory);}advisors.addAll(classAdvisors);}else {// Per target or per this.if (this.beanFactory.isSingleton(beanName)) {throw new IllegalArgumentException("Bean with name '" + beanName +"' is a singleton, but aspect instantiation model is not singleton");}// 原型模式MetadataAwareAspectInstanceFactory factory =new PrototypeAspectInstanceFactory(this.beanFactory, beanName);this.aspectFactoryCache.put(beanName, factory);advisors.addAll(this.advisorFactory.getAdvisors(factory));}}}this.aspectBeanNames = aspectNames;return advisors;}}}if (aspectNames.isEmpty()) {return Collections.emptyList();}// 利用缓存进行性能优化List advisors = new ArrayList<>();for (String aspectName : aspectNames) {List 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

@Override
// 通过AspectInstanceFactory获取Advisor集合
public List getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {Class aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();// <1> 校验切面类validate(aspectClass);// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator// so that it will only instantiate once.// 装饰者模式-增强AspectJInstanceFactory功能，使得该切面只被实例化一次MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);List advisors = new ArrayList<>();// <2> 查找该类下所有的非Pointcut注解的方法for (Method method : getAdvisorMethods(aspectClass)) {// <3> 获取AdvisorAdvisor 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.// <4> 如果切面是延迟初始化特性，则在执行链最开始增加一个advisor，直到目标方法被调用时再被初始化if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);advisors.add(0, instantiationAdvisor);}// Find introduction fields.// <5> 接口增强特性-@DeclareParents字段为拦截器增强动作for (Field field : aspectClass.getDeclaredFields()) {Advisor advisor = getDeclareParentsAdvisor(field);if (advisor != null) {advisors.add(advisor);}}// <6> 返回所有的Advisor数据return advisors;
}
private List getAdvisorMethods(Class aspectClass) {final List methods = new ArrayList<>();// 通过反射 查找Advisor目标方法，通过排除Pointcut注解方式实现ReflectionUtils.doWithMethods(aspectClass, method -> {// Exclude pointcutsif (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {methods.add(method);}}, ReflectionUtils.USER_DECLARED_METHODS);methods.sort(METHOD_COMPARATOR);return methods;
}
@Override
@Nullable
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,int declarationOrderInAspect, String aspectName) {validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());// 根据候选Advice方法的AspectJ注解 构建AspectJExpressionPointcutAspectJExpressionPointcut expressionPointcut = getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());if (expressionPointcut == null) {return null;}// 将方法包装为Advisor并返回return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

c.Spring是如何创建代理对象的？

Spring创建代理对象是通过ProxyFactory、AopProxyFactory、AopProxy协作创建代理对象

• AbstractAutoProxyCreator

protected Object createProxy(Class beanClass, @Nullable String beanName,@Nullable Object[] specificInterceptors, TargetSource targetSource) {if (this.beanFactory instanceof ConfigurableListableBeanFactory) {// 一般BeanFactory都会走这个流程 将当前Bean的原始类填充到该Bean的BeanDefinition中AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);}// <1> ProxyFactoryProxyFactory proxyFactory = new ProxyFactory();// <2> 将ProxyConfig信息拷贝一份proxyFactory.copyFrom(this);// <3> 是否代理目标类 如果为true 则直接采用CGLIB字节码提升，便没有必要再计算代理接口了。CGLIB是通过生成目标类的子类来进行字节码提升的if (!proxyFactory.isProxyTargetClass()) {// <3.1> 是否应该代理目标类 也就是是否采用CGLIB，这是通过BeanDefinition的Attribute属性决定的if (shouldProxyTargetClass(beanClass, beanName)) {proxyFactory.setProxyTargetClass(true);}else {// <3.2> 计算所要代理的接口evaluateProxyInterfaces(beanClass, proxyFactory);}}// <4> 获取Advisor数组对象Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);// <5> 将Advisor对象添加至代理工厂proxyFactory.addAdvisors(advisors);// <6> 设置目标源proxyFactory.setTargetSource(targetSource);// <7> 自定义代理工厂-子类去扩展customizeProxyFactory(proxyFactory);// <8> 设置代理工厂是否被冻结proxyFactory.setFrozen(this.freezeProxy);// <9> 在Advisor匹配时 是否跳过类过滤(ClassFilter)检查if (advisorsPreFiltered()) {proxyFactory.setPreFiltered(true);}// <10> 最终创建代理对象并返回return proxyFactory.getProxy(getProxyClassLoader());
}
// 构建Advisor数组
protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {// Handle prototypes correctly...// 处理指定的拦截器Advisor[] commonInterceptors = resolveInterceptorNames();List