深入分析 Spring 基于注解的 AOP 实现原理

ゞ浴缸里的玫瑰 2023-02-26 02:15 39阅读 0赞

## 一、AOP 的基本使用 ##

**AOP** 的使用分为三步走：

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

使用 `aop` 相关的注解必须先导入依赖：

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

下面以一个计算器的例子来介绍 AOP 的基本使用：

### 1、待增强类 ###

这是一个简单的计算器类，为了能够演示异常，所以创建了一个有除法的方法。

public class MathCalculator { 
    
        /** * 除法 * * @param i 被除数 * @param j 除数 * @return 返回运算结果 */
        public int div(int i, int j) { 
            return i / j;
        }
    }

### 2、增强类 ###

我们想通过 AOP 实现记录除法运行的日志信息，所以新建一个 Log 类。

@Aspect
    public class LogAspect { 
    
        /** * 抽取出来的切入点表达式 */
        @Pointcut("execution(* top.wsuo.aop.MathCalculator.*(..))")
        public void pointCut() { 
        }
    
        /** * 前置通知 * * @param joinPoint 连接点 */
        @Before("pointCut()")
        public void logStart(JoinPoint joinPoint) { 
            System.out.println(joinPoint.getSignature().getName() + "运行...参数列表是:{" + Arrays.toString(joinPoint.getArgs()) + "}");
        }
    
        /** * 后置通知 * * @param joinPoint 连接点 */
        @After("pointCut()")
        public void logEnd(JoinPoint joinPoint) { 
            System.out.println(joinPoint.getSignature().getName() + "结束...");
        }
    
        /** * 返回通知 * * @param joinPoint 连接点 * @param result 执行结果 */
        @AfterReturning(value = "pointCut()", returning = "result")
        public void logReturn(JoinPoint joinPoint, Object result) { 
            System.out.println(joinPoint.getSignature().getName() + "正常返回...运行结果:{" + result + "}");
        }
    
        /** * 异常通知 * * @param joinPoint 连接点 * @param exception 异常信息 */
        @AfterThrowing(value = "pointCut()", throwing = "exception")
        public void logException(JoinPoint joinPoint, Exception exception) { 
            System.out.println(joinPoint.getSignature().getName() + "出现异常...异常信息:{" + exception.getMessage() + "}");
        }
    }

### 3、配置类 ###

最后在配置类上开启注解版 AOP，同时注册组件到容器中。

@Configuration
    // Spring 中有很多 EnableXXX 代表开启某一项功能: 取代了配置
    @EnableAspectJAutoProxy
    public class MainConfigOfAOP { 
    
        @Bean
        public MathCalculator mathCalculator() { 
            return new MathCalculator();
        }
    
        @Bean
        public LogAspect logAspect() { 
            return new LogAspect();
        }
    }

### 4、测试 ###

测试及运行结果。

@Test
    public void test12() { 
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
        MathCalculator calculator = context.getBean(MathCalculator.class);
        System.out.println(calculator.div(4, 2));
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70][]

## 二、注解 AOP 的实现原理 ##

### 1、@EnableAspectJAutoProxy ###

整个 AOP 要想起作用，必须加上 `@EnableAspectJAutoProxy` 注解，这个注解的作用是什么呢？

点进去该注解：

@Import(AspectJAutoProxyRegistrar.class)
    public @interface EnableAspectJAutoProxy {

看到了要导入一个 `AspectJAutoProxyRegistrar` 类组件，它继承自一个接口 `ImportBeanDefinitionRegistrar`，这个接口我们之前讲过，他是添加自定义组件的接口，在这里：[https://blog.csdn.net/weixin\_43941364/article/details/107243459][https_blog.csdn.net_weixin_43941364_article_details_107243459]。

这说明 `@EnableAspectJAutoProxy` 注解的作用就是给容器中添加组件， 追踪 `AspectJAutoProxyRegistrar` 类的方法，发现有这么一段代码：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 1][]  
这段代码的作用就是先看一下容器中有没有

public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
    			"org.springframework.aop.config.internalAutoProxyCreator";

`internalAutoProxyCreator` 这个类，同时我们看到在调用上述方法的时候，传入了一个类型：  
![20200721144726756.png][]  
该类型是 `AspectJAwareAdvisorAutoProxyCreator` 实体类，看一下该类的继承结构。

### 2、AspectJAwareAdvisorAutoProxyCreator ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 2][]  
可以看到该类实现了一个接口，就是 `BeanPostProcessor` 接口，他是一个 [后置处理器][Link 1] 。这个接口是 Bean 生命周期相关的接口。

所以我们要重点分析一下该类的执行顺序，接下来 **打断点调试** 之前举的计算器的例子。

--------------------

### 3、容器的创建流程 ###

从容器启动开始分析：

首先传入配置类，创建 IOC 容器；然后注册配置类，调用 `refresh` 方法刷新容器；

#### 3.1、注册后置处理器 ####

**使用 `registerBeanPostProcessors(beanFactory)` 注册 Bean 的后置处理器，来拦截 Bean 的创建**

1.  先获取 IOC 容器中已经定义了的需要创建对象的所有 `BeanPostProcessor`  
    ![20200721152002480.png][]
2.  给容器中加别的 `BeanPostProcessor`
3.  优先注册实现了 `PriorityOrdered` 接口的 `BeanPostProcessor`
4.  再注册实现了 `Ordered` 接口的 `BeanPostProcessor`
5.  之后注册没实现 `Ordered` 接口的 `BeanPostProcessor`
6.  最后 `registerBeanPostProcessors` 执行，注册 `BeanPostProcessor` ，实际上就是创建 `BeanPostProcessor` 对象，保存在容器中。
    
    创建 `org.springframework.aop.config.internalAutoProxyCreator` 的 `BeanPostProcessor`，它的类型是 **`AnnotationAwareAspectJAutoProxyCreator`**。
    
    1.  首先创建 Bean 的实例 `instanceWrapper = createBeanInstance(beanName, mbd, args)`
    2.  然后给属性赋值 `populateBean(beanName, mbd, instanceWrapper)`
    3.  最后初始化 Bean `exposedObject = initializeBean(beanName, exposedObject, mbd)`
        
         *  `invokeAwareMethods(beanName, bean)` 初始化 Aware 接口的方法回调；
         *  `applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)` 执行后置处理器的 **`postProcessBeforeInitialization`** 方法；
         *  `invokeInitMethods(beanName, wrappedBean, mbd)` 执行自定义初始化方法；
         *  `applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)` 执行后置处理器的 **`postProcessAfterInitialization`** 方法；
    4.  到此为止 `AnnotationAwareAspectJAutoProxyCreator` 类型的 BeanPostProcessor 创建成功；
7.  创建完 `BeanPostProcessor` 对象之后，注册到 `beanFactory` 中
    
        registerBeanPostProcessors(beanFactory, internalPostProcessors)
        
        注册方法的实现：
        
        for (BeanPostProcessor postProcessor : postProcessors) { 
        	beanFactory.addBeanPostProcessor(postProcessor);
        }

到此为止 **`AnnotationAwareAspectJAutoProxyCreator`** 就算是创建成功了，而它作为一个后置处理器，肯定有作用，下面分析一下他作为后置处理器做了什么事情。

注意 `AnnotationAwareAspectJAutoProxyCreator` 是 `InstantiationAwareBeanPostProcessor` 类型的后置处理器。

#### 3.2、初始化剩下的单实例 Bean ####

**`finishBeanFactoryInitialization(beanFactory)` 完成 BeanFactory 的初始化工作**

1.  遍历获取容器中所有的 Bean，依次创建对象：`getBean、doGetBean、getSingleton`；
2.  创建 Bean（业务逻辑组件和切面组件）；
    
     *  先从缓存中获取当前 Bean，如果能获取到，说明 Bean 是之前创建过的，直接使用，否则再创建；
        
            先从缓存中检查有没有这个 Bean
            // Eagerly check singleton cache for manually registered singletons.
            Object sharedInstance = getSingleton(beanName);
            
            如果	他等于 null，才会继续执行下面的方法
            sharedInstance = getSingleton(beanName, () -> {
        
        只要创建好的 Bean 都会被缓存起来，这也是 Spring 保证单实例 Bean 的实现原理。
     *  `createBean` 创建 Bean：`AnnotationAwareAspectJAutoProxyCreator` 会在任何 Bean 创建完成之前先尝试返回 Bean 的实例，其实就是拦截；
        
        > BeanPostProcessor 是在对象创建Bean完成初始化前后调用的，而 InstantiationAwareBeanPostProcessor 是在创建Bean实例之前先尝试用后置处理器返回对象的。
        
         *  `Object bean = resolveBeforeInstantiation(beanName, mbdToUse)`，这句话的意思是希望后置处理器返回一个代理对象，如果能返回代理对象就使用，如果不能就继续；
            
                这个方法的实现就是拿到所有后置处理器，如果是 InstantiationAwareBeanPostProcessor，就执行 postProcessBeforeInstantiation 方法
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                
                if (bean != null) { 
                	bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
         *  `Object beanInstance = doCreateBean(beanName, mbdToUse, args)`，真正的去创建一个 Bean，和之前 **`3.6`** 的流程是一样的。

> 所以`AnnotationAwareAspectJAutoProxyCreator` 会在任何 Bean 创建完成之前先尝试返回 Bean 的实例，因为他实现了 `InstantiationAwareBeanPostProcessor` 接口，这个接口有两个方法，一个是`postProcessBeforeInstantiation`，另一个是`postProcessAfterInstantiation`，这两个方法是在 Bean 创建完成前后执行的，而 `BeanPostProcessor` 接口的两个方法是在创建完成并且初始化前后调用的。

1.  在每一个 Bean 创建之前调用 `postProcessBeforeInstantiation`方法，在这一步找出需要增强的 Bean；
    
     *  判断当前 Bean 是否在 `advisedBeans` 中（它保存了所有需要增强的 Bean ）
     *  判断当前 Bean 是否是基础类型 `isInfrastructureClass`![20200721214645229.png][]或者是切面。
     *  判断是否该跳过 `shouldSkip`：源码如下
        
            @Override
            protected boolean shouldSkip(Class<?> beanClass, String beanName) { 
            	// TODO: Consider optimization by caching the list of the aspect names
            	List<Advisor> candidateAdvisors = findCandidateAdvisors();
            	for (Advisor advisor : candidateAdvisors) { 
            		if (advisor instanceof AspectJPointcutAdvisor &&
            				((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) { 
            			return true;
            		}
            	}
            	return super.shouldSkip(beanClass, beanName);
            }
        
        首先获取所有候选的增强器，增强器就是切面里面的通知方法；
        
            0 = { InstantiationModelAwarePointcutAdvisorImpl@2180} "InstantiationModelAwarePointcutAdvisor: expression [pointCut()]; advice method [public void top.wsuo.aop.LogAspect.logStart(org.aspectj.lang.JoinPoint)]; perClauseKind=SINGLETON"
            1 = { InstantiationModelAwarePointcutAdvisorImpl@2181} "InstantiationModelAwarePointcutAdvisor: expression [pointCut()]; advice method [public void top.wsuo.aop.LogAspect.logEnd(org.aspectj.lang.JoinPoint)]; perClauseKind=SINGLETON"
            2 = { InstantiationModelAwarePointcutAdvisorImpl@2182} "InstantiationModelAwarePointcutAdvisor: expression [pointCut()]; advice method [public void top.wsuo.aop.LogAspect.logReturn(org.aspectj.lang.JoinPoint,java.lang.Object)]; perClauseKind=SINGLETON"
            3 = { InstantiationModelAwarePointcutAdvisorImpl@2183} "InstantiationModelAwarePointcutAdvisor: expression [pointCut()]; advice method [public void top.wsuo.aop.LogAspect.logException(org.aspectj.lang.JoinPoint,java.lang.Exception)]; perClauseKind=SINGLETON"
        
        可以看到这就是我们的那几个通知方法。  
        ![20200722064958718.png][]  
        只不过他把这些通知方法包装成为了一个 `List<Advisor> candidateAdvisors` 集合，每一个封装的通知方法的增强器是 `InstantiationModelAwarePointcutAdvisor`。  
        这段代码的逻辑就是判断每一个增强器是否是 `AspectJPointcutAdvisor` 类型的，如果是返回 **true** ，如果不是就返回 **false** ；
2.  在 Bean 创建之后调用 `postProcessAfterInitialization` 方法，在这一步增强需要增强的 Bean：
    
        @Override
        public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { 
        	if (bean != null) { 
        		Object cacheKey = getCacheKey(bean.getClass(), beanName);
        		if (!this.earlyProxyReferences.contains(cacheKey)) { 
        			return wrapIfNecessary(bean, beanName, cacheKey);
        		}
        	}
        	return bean;
        }
    
     *  在 **`wrapIfNecessary`** 方法中，获取当前 Bean 的所有增强器（**通知方法**），判断是否需要包装（增强）。
        
            // Create proxy if we have advice.
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        
            @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();
            }
        
        那么他是 **怎么找的增强器** 呢 ？我们继续查看方法调用。
        
            protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) { 
            	List<Advisor> candidateAdvisors = findCandidateAdvisors();
            	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
            	extendAdvisors(eligibleAdvisors);
            	if (!eligibleAdvisors.isEmpty()) { 
            		eligibleAdvisors = sortAdvisors(eligibleAdvisors);
            	}
            	return eligibleAdvisors;
            }
        
        这一步是找到候选的所有增强器，即哪些通知方法是需要切入当前 Bean 方法的。
        
        然后下面的方法 `findAdvisorsThatCanApply` 是获取到能在当前 Bean 使用的增强器，它使用了 `canApply` 方法判断。
        
            public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) { 
            	if (advisor instanceof IntroductionAdvisor) { 
            		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
            	}
            	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.
            		return true;
            	}
            }
        
        最后是给这些增强器排序。
    
    1.  保存当前 Bean 到 `advisedBeans` 中；
    2.  如果当前 Bean 需要增强，创建当前 Bean 的代理对象；
        
         *  获取所有的增强器（通知方法）
         *  保存到 `proxyFactory` 中；
            
                proxyFactory.getProxy(getProxyClassLoader());
         *  创建代理对象，Spring 自动决定使用哪一种动态代理
            
                @Override
                public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 
                	if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(
                		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)) { 
                			return new JdkDynamicAopProxy(config);
                		}
                		return new ObjenesisCglibAopProxy(config);
                	}
                	else { 
                		return new JdkDynamicAopProxy(config);
                	}
                }
            
            可以看到有两种自动代理，分别是 `JdkDynamicAopProxy` 和 `ObjenesisCglibAopProxy`。
            
            此时创建完成之后，代理对象为 **top.wsuo.aop.MathCalculator**，通过 Spring 增强的类型。  
            ![20200722074637364.png][]
    
    4.所以最后 `wrapIfNecessary(bean, beanName, cacheKey)` 方法就是返回了当前组件使用的 `cglib` 增强了的代理对象。
    
    5.以后容器中获取到的就是这个组件的 **代理对象** ，执行目标方法的时候，代理对象就会执行通知方法的流程。

#### 3.3、执行目标方法 ####

我们在测试方法上面打断点，看看除法运行的时候都有啥：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 3][]  
观察到此时的对象已经是 **cglib** 代理之后的对象了，这个对象中保存了详细信息，比如所有的增强器和目标对象。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 4][]

1.  下面进入到 `org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor` 的 `intercept` 方法中。
    
    本来是想执行目标的，但是代理之后就要先被拦截一下。
2.  然后根据 `ProxyFactory` 对象获取将要执行的目标拦截器链；
    
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)
    
    拦截器链是如何获取的？
    
    主要是在 `getInterceptorsAndDynamicInterceptionAdvice` 方法中。
    
     *  首先创建一个集合保存所有的拦截器，默认有 5 个
        
            List<Object> interceptorList = new ArrayList<>(advisors.length);
        
        这 5 个包括一个默认的 `org.springframework.aop.interceptor.ExposeInvocationInterceptor.ADVISOR` 和 4 个增强器。![20200722114837587.png][]
     *  遍历所有的增强器，将其转为 `Interceptor`。
        
            for (Advisor advisor : advisors)
            	registry.getInterceptors(advisor)
     *  将增强器转为 `List<MethodInterceptor>`：
        
         *  如果本来就是 `MethodInterceptor`，则直接加到集合中；
         *  如果不是，则使用 `AdvisorAdapter` 适配器转为 `MethodInterceptor`。
            
            怎么转的呢，其实这里就是强转然后包装了一下，源码如下。
            
                @Override
                public MethodInterceptor getInterceptor(Advisor advisor) { 
                	AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
                	return new AfterReturningAdviceInterceptor(advice);
                }
            
            可以看到这就是 **最终通知** 。
         *  转化完成返回 `MethodInterceptor` 数组。
     *  所以 **拦截器链** 就是每一个通知方法又被包装成为方法拦截器，利用 `MethodInterceptor` 的机制控制执行顺序。
3.  如果没有拦截器链，直接执行目标方法
    
        retVal = methodProxy.invoke(target, argsToUse);
4.  如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 `CglibMethodInvocation` 对象，并调用它的 `proceed` 方法。
    
        // We need to create a method invocation...
        retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
5.  拦截器链的触发过程，触发方法就是 `proceed`，所以只需要分析一下这个方法即可。
    
     *  如果没有拦截器或者是最后一个拦截器就执行目标方法
        
            if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { 
            	return invokeJoinpoint();
            }
     *  如果有拦截器就链式的获取每一个拦截器，拦截器执行 `invoke` 方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行。
        
            这里的返回值是还是拦截器，传入的是这个拦截器本身，每次调用都会减少一个长度，并且改变当前的拦截器，所以执行顺序是栈式的结构。
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        
         *  首先执行到 `interceptorOrInterceptionAdvice` 的实现类 **`ExposeInvocationInterceptor`**，就是方法本身；  
            ![20200722141140915.png][]  
            跟进去执行的是 `org.springframework.aop.interceptor.ExposeInvocationInterceptor` 的 `invoke` 方法，该方法的实现如下：
            
                @Override
                public Object invoke(MethodInvocation mi) throws Throwable { 
                	MethodInvocation oldInvocation = invocation.get();
                	invocation.set(mi);
                	try { 
                		return mi.proceed();
                	}
                	finally { 
                		invocation.set(oldInvocation);
                	}
                }
            
            这一块代码的核心业务是放在 `finally` 中的，所以肯定会执行，下面接着跟进去 `proceed` 方法：![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 5][]
         *  这个时候再次来到 proceed 方法，此时的下标变为 0，执行到 **`AspectJAfterThrowingAdvice`**，即异常通知；  
            ![20200722141519855.png][]  
            跟进去执行 `org.springframework.aop.aspectj.AspectJAfterThrowingAdvice` 的 `invoke` 方法，该方法的实现如下：
            
                @Override
                public Object invoke(MethodInvocation mi) throws Throwable { 
                	try { 
                		return mi.proceed();
                	}
                	catch (Throwable ex) { 
                		if (shouldInvokeOnThrowing(ex)) { 
                			invokeAdviceMethod(getJoinPointMatch(), null, ex);
                		}
                		throw ex;
                	}
                }
            
            注意到这里有异常的捕捉，所以异常发生时是在这里处理的，没有异常则不会执行，继续跟进 `proceed` 方法。  
            ![20200722142118779.png][]
         *  这个时候再次来到 proceed 方法，此时的下标变为 1，执行到 **`AfterReturningAdviceInterceptor`**，即返回（最终）通知；  
            ![20200722142521470.png][]  
            跟进去执行 `org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor` 的 `invoke` 方法，该方法的实现如下：
            
                @Override
                public Object invoke(MethodInvocation mi) throws Throwable { 
                	Object retVal = mi.proceed();
                	this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
                	return retVal;
                }
            
            就是先执行其他的，然后执行返回通知的内容，继续跟进 `proceed` 方法。  
            ![20200722142736469.png][]
         *  这个时候再次来到 proceed 方法，此时的下标变为 2，执行到 **`AspectJAfterAdvice`**，即后置通知；  
            ![20200722143013352.png][]  
            跟进去执行 `org.springframework.aop.aspectj.AspectJAfterAdvice` 的 `invoke` 方法，该方法的实现如下：
            
                @Override
                public Object invoke(MethodInvocation mi) throws Throwable { 
                	try { 
                		return mi.proceed();
                	}
                	finally { 
                		invokeAdviceMethod(getJoinPointMatch(), null, null);
                	}
                }
            
            就是先执行后面的前置通知，然后执行后置通知的内容，继续跟进 `proceed` 方法。  
            ![20200722143239406.png][]
         *  这个时候再次来到 proceed 方法，此时的下标变为 3，执行到 **`MethodBeforeAdviceInterceptor`**，即前置通知；  
            ![20200722143347511.png][]  
            跟进去执行 `org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor` 的 `invoke` 方法，该方法的实现如下：
            
                @Override
                public Object invoke(MethodInvocation mi) throws Throwable { 
                	this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
                	return mi.proceed();
                }
            
            这块代码是先执行自己的业务，再往下传递，我们继续跟进 `proceed` 方法：  
            ![20200722143503524.png][]  
            这个时候再次来到 proceed 方法，此时的下标变为 4，还是执行 **`MethodBeforeAdviceInterceptor`**  
            ![20200722143648584.png][]  
            但是现在已经开始回溯了，因为方法都已经入栈了，此时执行 **前置通知** 中的方法，控制台输出如下：  
            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 6][]  
            然后执行 **后置通知** ：  
            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 7][]  
            执行 **返回通知** ：  
            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 8][]  
            最后所有的通知执行完毕，由于没有异常产生，所以没有执行异常通知：  
            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 9][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70]: /images/20230209/94892db31264400b955842979adf87a5.png
[https_blog.csdn.net_weixin_43941364_article_details_107243459]: https://blog.csdn.net/weixin_43941364/article/details/107243459
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 1]: /images/20230209/81bfe57a336b43e8a46ef19f8e30a108.png
[20200721144726756.png]: https://img-blog.csdnimg.cn/20200721144726756.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200721144410878.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/weixin_43941364/article/details/107297600
[20200721152002480.png]: https://img-blog.csdnimg.cn/20200721152002480.png
[20200721214645229.png]: https://img-blog.csdnimg.cn/20200721214645229.png
[20200722064958718.png]: https://img-blog.csdnimg.cn/20200722064958718.png
[20200722074637364.png]: https://img-blog.csdnimg.cn/20200722074637364.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200722075931750.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200722075857317.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[20200722114837587.png]: https://img-blog.csdnimg.cn/20200722114837587.png
[20200722141140915.png]: https://img-blog.csdnimg.cn/20200722141140915.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200722141453188.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[20200722141519855.png]: https://img-blog.csdnimg.cn/20200722141519855.png
[20200722142118779.png]: https://img-blog.csdnimg.cn/20200722142118779.png
[20200722142521470.png]: https://img-blog.csdnimg.cn/20200722142521470.png
[20200722142736469.png]: https://img-blog.csdnimg.cn/20200722142736469.png
[20200722143013352.png]: https://img-blog.csdnimg.cn/20200722143013352.png
[20200722143239406.png]: https://img-blog.csdnimg.cn/20200722143239406.png
[20200722143347511.png]: https://img-blog.csdnimg.cn/20200722143347511.png
[20200722143503524.png]: https://img-blog.csdnimg.cn/20200722143503524.png
[20200722143648584.png]: https://img-blog.csdnimg.cn/20200722143648584.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200722143947340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200722144046716.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2020072214411478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200722144158322.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA==,size_16,color_FFFFFF,t_70