theme: github highlight: an-old-hope
1.入口
- spring版本：5.3.x
- AOP基本概念及使用
1.1 通过注解的方式开启aop功能
在一个配置类上使用@EnableAspectJAutoProxy注解，开启AOP功能。
@EnableAspectJAutoProxy
@Configuration
public class AppConfig {}
我们看下@EnableAspectJAutoProxy的代码：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
boolean proxyTargetClass() default false;
boolean exposeProxy() default false;
}
我们看到在这个注解中，它引入了@Import(AspectJAutoProxyRegistrar.class)类，通过类名可以判断，这个类是用来注册AspectJ代理。然后我们再看下该类的代码：
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@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);
}
}
}
}
再进入AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)方法：
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) { // 又调用了另外一个方法，顺着再看
return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
// 就是这里了，注册了一个类到spring容器中
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
我们看到最终其实调用了registerOrEscalateApcAsRequired()方法，并将AnnotationAwareAspectJAutoProxyCreator.class作为一个入参传入，看下该方法：
可以看到，最终就是将
AnnotationAwareAspectJAutoProxyCreator.class注册到spring容器中，该类就是AOP的入口类了，细节稍后细谈。
1.2通过配置xml的方式开启aop功能
在配置文件中添加如下配置，开启AOP功能：
<!-- 启用aop -->
<aop:aspectj-autoproxy />
该标签，不是spring的默认标签，属于自定义标签。在配置文件的头声明中肯定有引入aop xml的校验文件：
然后在spring-aop的jar包中，有一个spring.handlers文件，通过上面的头声明，可以找到
<aop:aspectj-autoproxy /> 标签的解析类：
http://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler
找到该类后，进入该类AopNamespaceHandler：
public class AopNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
// 主要看这行代码，就是我们xml中声明的标签
registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}
}
我们主要看aspectj-autoproxy标签的注册逻辑，它注册了AspectJAutoProxyBeanDefinitionParser解析类。进入该类，主要看parse()方法：
是不是和“注解”方式开启AOP有点像了。再进入该方法：
这里它调用了
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法。和前面“注解”的逻辑就都一样了，就是将AnnotationAwareAspectJAutoProxyCreator注册到spring容器中。
1.3 初识入口类
从前两点，知道了AnnotationAwareAspectJAutoProxyCreator就是aop的入口类，先看一下他的继承结构：
可以看到该类实现了
SmartInstantiationAwareBeanPostProcessor，它是一个BeanPostProcessor，也就是说在bean的初始化过程中，它是可以编辑、修改bean的。AOP初始化也就是从这里开始的：BeanPostProcessor.postProcessAfterInitialization(Object bean, String beanName)
2.AOP源码之旅
先导：几个重要、关键类：
- 个人经验，这一小节不要一开始就试图死记硬背，记住类结构。开始有个印象即可，后面看源码，理解源码逻辑的同时，再结合起来看（双屏真香~_~），边理解、边记忆，这样当你看懂源码的时候，这些类结构也记得7788了。
- 在spring中，Advisor是持有增强（advice）和切点（pointCut）的对象：
- Advisor的继承结构：
- 几种增强类型的类结构：
- 连接点（个人理解，组合调用advice，然后调用目标方法，起“连接”作用。即连接“增强”和“目标方法”）结构：
2.1 AOP-获取“增强”
从前一章节，已经知晓入口类就是AnnotationAwareAspectJAutoProxyCreator，它实现了BeanPostProcessor接口。在spring初始化bean的流程中，就会调用其postProcessAfterInitialization()方法，该方法就是aop的入口了。于是乎，我们就从AnnotationAwareAspectJAutoProxyCreator类的该方法开始，它在其父类AbstractAutoProxyCreator中实现了该方法：
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
// 根据给定bean的class和name构建一个key。格式：beanName，若是beanFactory加一个前缀&
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 将需要增强的类，装饰成代理类
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
进入wrapIfNecessary()方法:
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 已经处理过，则直接返回
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// 特殊类、指定的bean、已经创建代理的bean 无需“增强”
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 基础设施类（就是关于几个Advices、Pointcut的类） 或者 指定bean 不处理
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)){
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 获取适合当前bean的增强:返回的是List<Advisor>
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建具体的代理对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
该方法主要流程就是调用getAdvicesAndAdvisorsForBean()方法，获取增强。然后再通过createProxy()方法创建代理对象。我们先看获取增强的逻辑：
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
该方法是在父类AbstractAdvisorAutoProxyCreator中实现，就只调用了findEligibleAdvisors()方法，进入该方法，一探究竟：
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 在spring容器中寻找所有的advisor
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 筛选适合当前bean的advisor
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors); // 扩展接口
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors); // 排序（根据Order注解来的）
}
return eligibleAdvisors;
}
在findEligibleAdvisors()方法中，它先是查找spring容器中所有“增强”，然后再筛选符合当前bean的“增强”。我们先看findCandidateAdvisors()查找所有增强的方法，因为我们注入容器的实例对象是AnnotationAwareAspectJAutoProxyCreator，所以调用的是该类的此方法：
@Override
protected List<Advisor> findCandidateAdvisors() {
// Add all the Spring advisors found according to superclass rules.
// 根据父类规则，获取其所有advisor（父类加载的是配置文件中声明的AOP,即实现了 Advisor 的类）
List<Advisor> advisors = super.findCandidateAdvisors();
// Build Advisors for all AspectJ aspects in the bean factory.
// 寻找基于注解@Aspect的切面
if (this.aspectJAdvisorsBuilder != null) {
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
}
可以看到该方法先调用了父类AbstractAdvisorAutoProxyCreator同名方法获取增强，先看一下父类获取增强的逻辑：
protected List<Advisor> findCandidateAdvisors() {
Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
return this.advisorRetrievalHelper.findAdvisorBeans();
}
父类是利用一个辅助类BeanFactoryAdvisorRetrievalHelper来获取增强，进入该方法：
public List<Advisor> findAdvisorBeans() {
// 判断缓存中是否已经有advisor
String[] advisorNames = this.cachedAdvisorBeanNames;
if (advisorNames == null) {
// 获取容器中所有Advisor的beanName。此时容器中的advisor都是通过xml声明的。
// 通过注解声明的还没加载进来,也不会实现Advisor接口
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
if (advisorNames.length == 0) {
return new ArrayList<>();
}
List<Advisor> advisors = new ArrayList<>();
for (String name : advisorNames) {
if (isEligibleBean(name)) { // 默认返回true，可以覆盖方法
if (this.beanFactory.isCurrentlyInCreation(name)) { // 过滤正在创建中的bean
if (logger.isTraceEnabled()) {
logger.trace("Skipping currently created advisor '" + name + "'");
}
}
else {
try {
// 直接从容器中获取Advisor
advisors.add(this.beanFactory.getBean(name, Advisor.class));
}
catch (BeanCreationException ex) {
Throwable rootCause = ex.getMostSpecificCause();
if (rootCause instanceof BeanCurrentlyInCreationException) {
BeanCreationException bce = (BeanCreationException) rootCause;
String bceBeanName = bce.getBeanName();
if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
if (logger.isTraceEnabled()) {
logger.trace("Skipping advisor '" + name +
"' with dependency on currently created bean: " + ex.getMessage());
}
}
}
throw ex;
}
}
}
}
return advisors;
}
这里获取增强的逻辑比较简单，对照着写的注释理解，一目了然。从父类获取完增强后，然后我们返回AnnotationAwareAspectJAutoProxyCreator.findCandidateAdvisors()方法继续看子类获取增强的逻辑this.aspectJAdvisorsBuilder.buildAspectJAdvisors()进入该方法：
/**
* 返回所有添加了Aspect注解的bean，并返回advice方法
*/
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
if (aspectNames == null) { // 缓存中没有，才重新加载
synchronized (this) {
aspectNames = this.aspectBeanNames; // 单例双重检测
if (aspectNames == null) {
List<Advisor> advisors = new ArrayList<>();
aspectNames = new ArrayList<>();
/* 获取容器中所有的beanName */
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
// 循环beanName
for (String beanName : beanNames) {
// 不合法的bean则略过，由子类定义规则，默认返回true
if (!isEligibleBean(beanName)) {
continue;
}
Class<?> beanType = this.beanFactory.getType(beanName, false);
if (beanType == null) {
continue;
}
// 是否存在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);
// 解析标记AspectJ注解类中的 增强方法
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
// 若bean是单例，则直接缓存增强
this.advisorsCache.put(beanName, classAdvisors);
}
else {
// 若bean不是单例，每次都要新获取，则缓存工厂类
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<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;
}
这个方法的代码看着有点多，它是用于解析基于@Aspect注解的切面，主要流程如下：
- 判断缓存，是否已经加载过基于
@Aspect注解的切面。若存在缓存，则直接从缓存中取增强。 - 缓存不存在，则获取spring IOC容器中所有的beanName。
- 循环所有beanName，判断对应的类是否存在
@Aspect注解。 - 存在
@Aspect注解，则解析其声明的增强、切点，然后缓存。 其主要流程，并不复杂。在这个方法中，我们重点学习解析增强的逻辑：
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
// 解析标记了AspectJ注解的类，获取增强
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
可以看到，它首先用beanFactory和beanName构建了一个MetadataAwareAspectInstanceFactory对象，然后将其作为参数，调用了AspectJAdvisorFactory.getAdvisors()方法，真正实现该方法的是其子类ReflectiveAspectJAdvisorFactory。我们直接看ReflectiveAspectJAdvisorFactory.getAdvisors():
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
/* 获取标记为 AspectJ 的class */
Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
/* 获取标记为 AspectJ 的class name */
String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
/* 对标记为 AspectJ 的类进行基本的验证 */
validate(aspectClass);
// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
// so that it will only instantiate once.
MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
List<Advisor> advisors = new ArrayList<>();
// 获取本类及其父类的所有方法（排除了@point方法、抽象方法），并循环
for (Method method : getAdvisorMethods(aspectClass)) {
// 构建增强
Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
if (advisor != null) {
advisors.add(advisor);
}
}
// If it's a per target aspect, emit the dummy instantiating aspect.
if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
// 如果寻找的增强器不为空而且又配置了增强延迟初始化，那么需要加入同步实例化增强器
Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
advisors.add(0, instantiationAdvisor);
}
// Find introduction fields.
// DeclareParents 注解作用：用来“给被代理对象添加一些方法”
for (Field field : aspectClass.getDeclaredFields()) {
Advisor advisor = getDeclareParentsAdvisor(field);
if (advisor != null) {
advisors.add(advisor);
}
}
return advisors;
}
这里我们先看获取类所有方法的逻辑getAdvisorMethods(aspectClass)：
private List<Method> getAdvisorMethods(Class<?> aspectClass) {
List<Method> methods = new ArrayList<>();
// 获取类（父类）的所有方法，排除了@Pointcut注解的方法
ReflectionUtils.doWithMethods(aspectClass, methods::add, adviceMethodFilter);
if (methods.size() > 1) {
methods.sort(adviceMethodComparator); // 排序
}
return methods;
}
该方法，主要就是获取类的所有方法，然后对方法进行排序。我们关注一下排序的逻辑，调用的是List自带的sort()方法，传入一个Comparator对象，关键是这个Comparator对象：
private static final Comparator<Method> adviceMethodComparator;
static {
// 按照Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class的顺序排序
Comparator<Method> adviceKindComparator = new ConvertingComparator<>(
new InstanceComparator<>(Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
(Converter<Method, Annotation>) method -> {
AspectJAnnotation<?> ann = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
return (ann != null ? ann.getAnnotation() : null);
});
Comparator<Method> methodNameComparator = new ConvertingComparator<>(Method::getName);
adviceMethodComparator = adviceKindComparator.thenComparing(methodNameComparator);
}
在这里，将方法按“增强”的类型，排了一下序，这里就是对“增强”进行了第一次排序。
然后我们返回getAdvisors()方法,接着看构建增强的方法getAdvisor()：
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,int declarationOrderInAspect, String aspectName) {
// 对切面类，进行基础验证
validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
// 获取切点信息
AspectJExpressionPointcut expressionPointcut = getPointcut(
candidateAdviceMethod,aspectInstanceFactory.getAspectMetadata().getAspectClass());
if (expressionPointcut == null) {
return null;
}
// 根据切点信息，生成advisor
return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}
获取切点信息getPointCut()方法主要是解析注解上的信息（增强类型、切点表达式等），封装成AspectJExpressionPointcut对象，没有特殊的逻辑。这里我们主要看下返回实例InstantiationModelAwarePointcutAdvisorImpl对象（它是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;
// 是否延迟加载
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;
}
else {
// A singleton aspect.
this.pointcut = this.declaredPointcut;
this.lazy = false;
// 实例化advice对象，会根据不通的环绕方式，封装成不同的advice
this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
}
}
构造函数中主要是给成员属性赋值，主要看下instantiatedAdvice对象的赋值：
private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
return (advice != null ? advice : EMPTY_ADVICE);
}
继续进入this.aspectJAdvisorFactory.getAdvice()方法：
public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
// 获取切面类
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)) {
throw new AopConfigException("Advice must be declared inside an aspect type: " +
"Offending method '" + candidateAdviceMethod + "' in class [" +
candidateAspectClass.getName() + "]");
}
if (logger.isDebugEnabled()) {
logger.debug("Found AspectJ method: " + candidateAdviceMethod);
}
AbstractAspectJAdvice springAdvice;
// 根据不同的注解类型封装不同的advice
switch (aspectJAnnotation.getAnnotationType()) {
case AtPointcut:
if (logger.isDebugEnabled()) {
logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
}
return null;
case AtAround:
springAdvice = new AspectJAroundAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtBefore:
springAdvice = new AspectJMethodBeforeAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfter:
springAdvice = new AspectJAfterAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfterReturning:
springAdvice = new AspectJAfterReturningAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterReturningAnnotation.returning())) {
springAdvice.setReturningName(afterReturningAnnotation.returning());
}
break;
case AtAfterThrowing:
springAdvice = new AspectJAfterThrowingAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
}
break;
default:
throw new UnsupportedOperationException(
"Unsupported advice type on method: " + candidateAdviceMethod);
}
// Now to configure the advice...
springAdvice.setAspectName(aspectName);
springAdvice.setDeclarationOrder(declarationOrder);
String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
if (argNames != null) {
springAdvice.setArgumentNamesFromStringArray(argNames);
}
springAdvice.calculateArgumentBindings();
return springAdvice;
}
在该方法中可以看到根据增强的类型不通，将增强分别注册成了：AspectJAroundAdvice、AspectJAfterAdvice、 AspectJMethodBeforeAdvice、AspectJAfterReturningAdvice、AspectJAfterThrowingAdvice.另外这里我们需要关注下springAdvice.calculateArgumentBindings()方法：
public final void calculateArgumentBindings() {
// The simple case... nothing to bind.
// 没有入参，直接返回
if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
return;
}
int numUnboundArgs = this.parameterTypes.length;
Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
if (maybeBindJoinPoint(parameterTypes[0]) // 绑定了参数 JoinPoint
|| maybeBindProceedingJoinPoint(parameterTypes[0]) // 绑定了参数：ProceedingJoinPoint
|| maybeBindJoinPointStaticPart(parameterTypes[0])) { // 绑定了参数:JoinPoint.StaticPart
// 注意该参数只能放在第一个位置，否则会报错。注意他们是aspectj包中的对象，不是spring的
numUnboundArgs--;
}
if (numUnboundArgs > 0) { // 绑定其他我们自定义的参数
// need to bind arguments by name as returned from the pointcut match
bindArgumentsByName(numUnboundArgs);
}
this.argumentsIntrospected = true;
}
在这个方法中，我们就可以通过源码的方式知道，增强方法传参数时，如果入参有JoinPoint参数，那么它必须放在第一个入参。到这里，我们就已经知道spring是如何构建一个advisor对象的了。代码逻辑中，还有“延迟加载的增强”、“引介增强”的逻辑，由于平时也没用到过，就暂时都没研究了。我们再返回到getAdvisors()方法，可以看到它获取到advisor的List对象也就直接返回了。接着我们返回上一层继续看findEligibleAdvisors()方法，再回顾一下:
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 在spring容器中寻找所有的advisor
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 寻找适合当前bean的advisor
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors); // 扩展接口
if (!eligibleAdvisors.isEmpty()) {
// 排序(根据Order注解来排)
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
在得到容器中所有的advisor后，接着看findAdvisorsThatCanApply()方法，筛选适合当前bean的Advisor：
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
// 使用了ThreadLocal保证线程安全
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
// 寻找适合当前bean的增强
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
可以看到spring将筛选的步骤，交给了AopUtils类来做，进入该方法：
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
List<Advisor> eligibleAdvisors = new ArrayList<>();
for (Advisor candidate : candidateAdvisors) {
// 判断 引介增强（DeclareParents注解声明的增强） 是否符合增强当前bean
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {
// “引介增强” 前面已经判断过了，直接跳过
if (candidate instanceof IntroductionAdvisor) {
// already processed
continue;
}
// 判断增强是否符合当前bean
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
判断增强是否符合当前bean主要是通过canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions)方法：
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) { // 引介增强
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
//在前面是初始化成 InstantiationModelAwarePointcutAdvisorImpl对象，它是PointcutAdvisor的子类
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
// 如果增强没有设置切点信息，我们假设这个增强是适合当前bean的
return true;
}
}
再进入canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions)（重载）方法：
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
// 最终判断，是由aspectJ jar进行逻辑判断的
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
Set<Class<?>> classes = new LinkedHashSet<>();
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
for (Class<?> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {// 方法级别上判断，是否符和当前bean
return true;
}
}
}
return false;
}
可以看到判断“增强”是否适合当前bean，主要是利用PointCut接口获取ClassFilter和MethodMatcher实例，然后调用其matches()方法进行判断。但最终的实现用的是aspectJ三方jar包的功能。这里主要学习spring的源码逻辑，具体逻辑，就不细究了，感兴趣的可以搜索相关资料看看（目前个人没啥兴趣~_~）。至此已经筛选出符合当前bean的增强了。然后再次返回findEligibleAdvisors()方法，再次对增强，排了一次序，但这次是根据@Order来排的。ok，至此成功获取符合当前bean的增强了。
2.2 创建代理对象
- 本文主要学习基于java接口动态代理的AOP。在看spring如何创建代理对象前，先回顾一下java的动态代理：动态代理
- 前面我们已经获取到了适合当前bean的增强对象。接下来就是创建代理对象了，接着返回看
AbstractAutoProxyCreator.wrapIfNecessary()方法，看其中创建代理对象的方法：
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this); // 复制当前类的属性
if (proxyFactory.isProxyTargetClass()) {
// 基于JDK动态代理
if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
// 获取类的接口，并将接口赋值到代理工厂类中
for (Class<?> ifc : beanClass.getInterfaces()) {
proxyFactory.addInterface(ifc);
}
}
}
else {
// No proxyTargetClass flag enforced, let's apply our default checks...
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
/*将所有增强都装饰成advisor（除了自己写的增强，还有部分公共增强，默认是没有公共的增强的）*/
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors); // 加入增强
proxyFactory.setTargetSource(targetSource); // 设置要代理的类
customizeProxyFactory(proxyFactory); // 定制化代理类(可扩展接口)
/*用来控制代理工厂被配置之后，是否还允许修改通知。默认值为false（即在代理被配置后，不允许修改代理的配置）*/
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
}
// 通过工厂类创建代理对象
return proxyFactory.getProxy(classLoader);
}
可以看到代理类是通过工厂类创建的，我们先看下proxyFactory的继承结构：
源码中对Advised类的释义是：AOP代理工厂的父类，该工厂必须含有一个配置清单，清单含有Interceptors和其他advice, Advisors,和代理接口。我们接着看工厂类创建代理的过程proxyFactory.getProxy()方法：
public Object getProxy(@Nullable ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
接着看createAopProxy()方法：
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
先是调用getAopProxyFactory()方法获取AOP代理工厂类，其实就是DefaultAopProxyFactory类，接着看该类的createAopProxy()方法：
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (!NativeDetector.inNativeImage() &&
// 用来控制通过CGLIB创建的代理使用激进的优化策略。除非完全了解AOP代理处理优化，否则不推荐用户使用这个设置。目前这个属性只用于CGLIB代理
(config.isOptimize()
// 这个属性为true时，目标类本身被代理而不是目标类的接口。true，创建CGLIB代理。设置方式：<aop:aspectj-autoproxy- proxy-target-class="true"/>
|| config.isProxyTargetClass()
// 是否存在代理类（没有实现接口，创建CGLIB代理；）
|| hasNoUserSuppliedProxyInterfaces(config))) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass)) {
// 符合一定条件，创建JDK动态代理
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
可以看到返回了一个JdkDynamicAopProxy实例，然后看下该类的继承结构：
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable{}
看到没！它实现了InvocationHandler接口，是不是熟悉的感觉了。那么该类必定会有一个invoke()方法和getProxy()方法。我们先看下它的getProxy()方法：
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isTraceEnabled()) {
logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
}
// 返回代理对象
return Proxy.newProxyInstance(determineClassLoader(classLoader),this.proxiedInterfaces, this);
}
看到这行返回代理对象的代码，是不是和我们自己编写、基于接口的java动态代理的逻辑一毛一样了了。然后我们再看下它的构造函数，了解一下他的结构：
public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
Assert.notNull(config, "AdvisedSupport must not be null");
if (config.getAdvisorCount() == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
throw new AopConfigException("No advisors and no TargetSource specified");
}
this.advised = config;
// 代理的接口
this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces); // 是否有equal和hashCode方法
}
这里主要赋值了advised属性和proxiedInterfaces，这里我们再回顾一下Advised对象释义：它AOP代理工厂的父类，该工厂必须含有一个配置清单，清单含有Interceptors 和其他 advice, Advisors,和代理接口。这样就创建好一个代理对象了。
2.3 调用一个方法的增强流程
通过上一节，我们已经获取到了代理对象JdkDynamicAopProxy，那么当我们调用一个方法时，必定是先执行JdkDynamicAopProxy.invoke()方法：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Object target = null;
// ...
// 省略了一些无关主流程的代码
// ...
Object retVal;
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// Get the interception chain for this method.
// 获取适合当前方法的拦截器链(即增强),会把advisor封装成MethodInterceptor对象
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
// 如果没有发现任何拦截器，则直接调用切点方法
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// 将拦截器封装在ReflectiveMethodInvocation
// 以便使用其proceed方法，进行递归调用
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
}
Class<?> returnType = method.getReturnType();
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
retVal = proxy;
}
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
整体流程：
- 获取适合当前方法的拦截器链(即增强)
- 调用拦截器链，返回执行结果
先看this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)获取拦截器链的逻辑：
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method);
List<Object> cached = this.methodCache.get(cacheKey);
if (cached == null) {
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass);
this.methodCache.put(cacheKey, cached);
}
return cached;
}
又将“获取拦截器链”的功能委托给了advisorChainFactory对象，进入该类：
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, @Nullable Class<?> targetClass) {
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
Advisor[] advisors = config.getAdvisors(); // 增强对象
List<Object> interceptorList = new ArrayList<>(advisors.length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
for (Advisor advisor : advisors) { // 循环增强
// 由切点驱动的增强（我们大部分的切面增强，应该都是这个）
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
// 再次校验了增强是否符和当前bean
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
boolean match;
if (mm instanceof IntroductionAwareMethodMatcher) {
if (hasIntroductions == null) {
hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
}
match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
}
else {
match = mm.matches(method, actualClass);
}
// 如果增强适合当前方法，将增强装饰成拦截器（MethodInterceptor）
if (match) {
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
if (mm.isRuntime()) {
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
// 引介增强
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}
获取拦截链的流程，我们主要看下将advisor适配成MethodInterceptor的逻辑：registry.getInterceptors(advisor)。spring是将它委托了给DefaultAdvisorAdapterRegistry类，进入该类：
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
// 实现了MethodInterceptor接口的，直接添加（AspectJAroundAdvice、AspectJAfterAdvice、AspectJAfterThrowingAdvice）
if (advice instanceof MethodInterceptor) {
interceptors.add((MethodInterceptor) advice);
}
// 没有实现MethodInterceptor接口的，利用适配器适配（AspectJMethodBeforeAdvice、AspectJAfterReturningAdvice）
for (AdvisorAdapter adapter : this.adapters) {
if (adapter.supportsAdvice(advice)) {
interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
return interceptors.toArray(new MethodInterceptor[0]);
}
没有实现MethodInterceptor接口的增强类型，被适配之后的类：
原始增强类 适配后的类 AspectJMethodBeforeAdvice MethodBeforeAdviceInterceptor AspectJAfterReturningAdvice AfterReturningAdviceInterceptor将Advisor装饰成MethodInterceptor（拦截器）后，接着就是执行拦截器（增强）了。它先是初始化了一个ReflectiveMethodInvocation对象：
protected ReflectiveMethodInvocation(
Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,@Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
this.proxy = proxy; // 代理对象
this.target = target; // 真正的bean对象
this.targetClass = targetClass; // 目标类的class对象
this.method = BridgeMethodResolver.findBridgedMethod(method); // 要执行的目标方法
// 目标方法的参数
this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
// 拦截器链
this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
}
接着我们看下ReflectiveMethodInvocation类的继承结构：
可以看到ReflectiveMethodInvocation其实是一个Joinpoint。看到这里，可以在再仔细回忆、思考一下spring中连接点Joinpint的含义。我也是学习到这里才对连接点的含义逐渐清晰，之前看别人的解释，总是一知半解。另外AspectJ jar包中也有一个JoinPoint类，看代码的时候注意区别一下，别搞混淆了（我就混淆了，好一会才反应过来）。
接着看真正执行拦截器（增强）的方法ReflectiveMethodInvocation.proceed()：
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
// 执行完所有增强后，执行“目标”方法
if (this.currentInterceptorIndex==this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 取出下一个“增强”
Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
// 动态匹配调用
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
} else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
// 不匹配则不执行当前拦截器，执行下一个
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
// 普通拦截器，直接调用拦截器。
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
我们的增强一般都是普通“拦截器”，都是直接调用MethodInterceptor.invoke,我们的增强对象在前面说过，要不实现了MethodInterceptor接口，要不已经被适配成了MethodInterceptor子类。我们按照增强类型，一个一个看过来：
- @Around 对应
AspectJAroundAdvice类： 直接看该类的invoke()方法：
public Object invoke(MethodInvocation mi) throws Throwable {
if (!(mi instanceof ProxyMethodInvocation)) {
throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
}
ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
// 注意注意，就是在这一步，把spring的Joinpoint对象转化为了Aspectj的JoinPoint对象
ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
JoinPointMatch jpm = getJoinPointMatch(pmi);
return invokeAdviceMethod(pjp, jpm, null, null); // 调用增强方法
}
我们再接着看调用增强的方法invokeAdviceMethod(),它是在父类AbstractAspectJAdvice中实现的：
protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
@Nullable Object returnValue, @Nullable Throwable t) throws Throwable {
return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
}
它先是调用argBinding()方法获取目标方法的参数列表，然后将其作为入参，调用invokeAdviceMethodWithGivenArgs()方法：
protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
Object[] actualArgs = args;
if (this.aspectJAdviceMethod.getParameterCount() == 0) {
actualArgs = null;
}
try {
ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
// 执行增强方法
return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
}
catch (IllegalArgumentException ex) {
throw new AopInvocationException("Mismatch on arguments to advice method [" +
this.aspectJAdviceMethod + "]; pointcut expression [" +
this.pointcut.getPointcutExpression() + "]", ex);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
没有特殊、复杂的逻辑。执行到这里，它就会调用环绕增强，比如我们前面的例子：
这里需要注意，环绕通知的增强方法，第一个入参必须是ProceedingJoinPoint，在执行完前置逻辑后，调用point.proceed()方法，继续调用下一个增强。要不然程序就在这里中断了。
- @Before 对应
AspectJMethodBeforeAdvice,但未实现MethodInterceptor接口，被装饰为MethodBeforeAdviceInterceptor类，直接看他的invoke()方法：
public Object invoke(MethodInvocation mi) throws Throwable {
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
return mi.proceed();
}
可以看到它直接先是调用的advice.before方法，即增强内容AspectJMethodBeforeAdvice.before()方法：
public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
它和AspectJAroundAdvice一样，都是通过调用父类AbstractAspectJAdvice.invokeAdviceMethod()方法，来执行增强方法的。执行完增强方法后，再调用mi.proceed()方法，递归继续执行下一个增强。
- @After 对应
AspectJAfterAdvice类，直接看他的invoke()方法：
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
finally {
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
可以看到它是直接调用了mi.proceed()方法,先递归执行下一个增强，然后在finally中再执行增强方法。
- @AfterReturning 对应
AspectJAfterReturningAdvice类，但未实现MethodInterceptor接口，被装饰为AfterReturningAdviceInterceptor类，直接看他的invoke()方法：
public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
可以看到，它是先直接调用mi.proceed()方法，先递归执行下一个增强，然后再执行增强方法this.advice.afterReturning():
public void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {
if (shouldInvokeOnReturnValueOf(method, returnValue)) {
invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
}
}
可以看到后置通知，它可以将“目标方法”的返回值，传入后置增强方法中的。
- @AfterThrowing 对应
AspectJAfterThrowingAdvice类，直接看他的invoke()方法：
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}
}
可以看到，它是先直接调用mi.proceed()方法递归执行下一个增强。假如目标方法执行过程中，抛出异常了，就会调用其增强方法。
- 看源码过程中，发现还有一个增强
ThrowsAdviceInterceptor,看其效果和AspectJAfterThrowingAdvice一样。要求增强类实现ThrowsAdvice接口。至今个人没有用过。感兴趣的小伙伴可以研究一下。 - 看完5种增强类型的源码，也可以看出他们的执行顺序必定是：Around或Before >> AfterReturning >> AfterThrowing >> After
3.总结
以上就是spring AOP基于java动态代理的源码。spring源码被称为“面对对象”语言的典范，带着“面对对象”的思想去读spring的源码也会另一番收获。我在读spring源码时，常常看着看着就不知道跳到那个类去了，所以针对各个类画时序图就非常重要了，各位也可以尝试。下面是我在阅读时，关于各个流程画的时序图，供参考：
个人理解，如有错误欢迎评论区指正。也希望有小伙伴可以一起交流讨论、欢迎评论区留言。
网页上由于查看类的继承结构，方法跳转等诸多限制，阅读源码，强烈建议在IDE中阅读。本人阅读spring源码的记录：https://gitee.com/longshunchen/spring_source
参考图书：郝佳前辈的《spring源码深度解析》
相关内容