1.【Spring注解驱动开发】二狗子让我给他讲讲@EnableAspectJAutoProxy注解
2.Spring源码插播一个创建代理对象的码解wrapIfNecessary()方法
3.如何理解Spring的AOP？
4.springaop原理
5.谈谈对springaop的理解？
6.76 张图，剖析 Spring AOP 源码，码解小白居然也能看懂，码解大神，码解请收下我的码解膝盖！

【Spring注解驱动开发】二狗子让我给他讲讲@EnableAspectJAutoProxy注解

       在配置类上添加@EnableAspectJAutoProxy注解，码解logo带采集源码能够开启注解版的码解AOP功能。这意味着，码解如果在AOP中要启用注解版的码解AOP功能，就需要在配置类上添加@EnableAspectJAutoProxy注解。码解让我们来看看@EnableAspectJAutoProxy注解的码解源码，如下所示。码解

       从源码可以看出，码解@EnableAspectJAutoProxy注解使用@Import注解引入了AspectJAutoProxyRegister.class对象。码解那么，码解AspectJAutoProxyRegistrar是做什么的呢？我们点击到AspectJAutoProxyRegistrar类的源码中，如下所示。

       可以看到AspectJAutoProxyRegistrar类实现了ImportBeanDefinitionRegistrar接口。我们回顾ImportBeanDefinitionRegistrar接口的定义，如下所示。

       通过ImportBeanDefinitionRegistrar接口，我们可以实现将自定义的组件添加到IOC容器中。也就是说，@EnableAspectJAutoProxy注解使用AspectJAutoProxyRegistrar对象自定义组件，并将相应的组件添加到IOC容器中。

       在AspectJAutoProxyRegistrar类的registerBeanDefinitions()方法中设置断点，我们以debug的方法来运行AopTest类的testAop()方法。当程序运行到断点位置时，我们可以看到程序已经暂停，IDEA的左下角显示了方法的调用栈。

       在registerBeanDefinitions()方法中，首先调用AopConfigUtils类的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法来注册registry。在registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法中，直接调用了重载的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法。在重载的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法中，传入了AnnotationAwareAspectJAutoProxyCreator.class对象。

       在registerOrEscalateApcAsRequired()方法中，接收到的易语言ftp管理源码Class对象的类型为：org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator。然后，我们继续跟进代码。

       在registerOrEscalateApcAsRequired()方法中，首先判断registry是否包含org.springframework.aop.config.internalAutoProxyCreator类型的bean。接下来，我们继续看代码。

       最终，AopConfigUtils类的registerOrEscalateApcAsRequired()方法中，会通过registry调用registerBeanDefinition()方法注册组件，并注册的bean的名称为org.springframework.aop.config.internalAutoProxyCreator。

       接下来，我们继续看AspectJAutoProxyRegistrar类的registerBeanDefinitions()源码。我们通过AnnotationConfigUtils类的attributesFor方法来获取@EnableAspectJAutoProxy注解的信息。接下来，我们继续判断proxyTargetClass属性的值是否为true，如果为true则调用AopConfigUtils类的forceAutoProxyCreatorToUseClassProxying()方法；继续判断exposeProxy属性的值是否为true，如果为true则调用AopConfigUtils类的forceAutoProxyCreatorToExposeProxy()方法。

       综上所述，向Spring的配置类上添加@EnableAspectJAutoProxy注解后，会向IOC容器中注册AnnotationAwareAspectJAutoProxyCreator。

       了解了这些之后，我们就可以关注「冰河技术」微信公众号，后台回复不同的关键字获取相应的PDF文档。这些文档都是由冰河原创并整理的超硬核教程，包括《深入浅出Java 种设计模式》、《Java8新特性教程》和《亿级流量下的分布式限流解决方案》，都是面试必备的资料。

       最后，如果你觉得这篇文章对你有帮助，别忘了点个赞，给个在看和转发，让更多的人看到，一起学习，一起进步！

Spring源码插播一个创建代理对象的wrapIfNecessary()方法

       在深入探讨Spring源码中创建代理对象的`wrapIfNecessary()`方法之前，先简要回顾其作用。`wrapIfNecessary()`方法主要任务是php学校管理系统源码基于一系列条件判断，决定是否为Bean创建代理对象，从而实现AOP（面向切面编程）的功能。下面，我们将逐步解析这一方法的内部逻辑。

       `wrapIfNecessary()`方法的执行流程可以分为以下阶段：

       1. **条件判断**：

        - **已处理Bean**：首先检查传入的Bean是否已处理过，即在`targetSourcedBeans`集合中是否存在该Bean的记录。

        - **已创建代理**：接着检查`advisedBeans`集合中是否已有该Bean的代理对象缓存，以确认是否需要再次创建代理。

        - **自定义Bean**：通过`isInfrastructureClass()`方法判断是否为Spring自带的Bean，排除此类无需代理的情况。

        - **无需代理**：如果上述任一条件满足，则直接返回传入的Bean对象，无需创建代理。

       2. **代理创建**：

        - **获取Advices和Advisors**：如果上述条件均不满足，则调用`getAdvicesAndAdvisorsForBean()`方法获取当前Bean的Advices和Advisors信息。

        - **判断适配**：通过`findEligibleAdvisors()`方法从候选通知器中筛选出适合当前Bean的Advisors，确保这些Advisors可以应用到当前Bean。

        - **实现逻辑**：通过`findCandidateAdvisors()`和`findAdvisorsThatCanApply()`方法进一步筛选、拓展、排序Advisors，最终获取到实际需要应用的Adviser集合。

       3. **代理构建**：

        - **决策**：根据获取的Advisors判断是否需要创建代理。若结果非`DO_NOT_PROXY`，则调用`createProxy()`方法创建代理对象，并缓存以备后续使用。

        - **过程**：在创建代理过程中，`exposeTargetClass()`方法设置Bean的属性，`shouldProxyTargetClass()`方法决定使用JDK动态代理还是CGLIB动态代理，`evaluateProxyInterfaces()`方法添加代理接口，最终通过`getProxy()`方法构建代理对象。

       4. **优化与扩展**：

        - **Advisors排序**：调用`sortAdvisors()`方法对Advisors进行排序，优化代理逻辑执行顺序。

        - **扩展与定制**：通过`extendAdvisors()`方法提供扩展点，允许对目标Advisor进行进一步定制。

       5. **构建代理对象**：

        - **代理工厂**：通过`AopProxyFactory`初始化代理工厂，并在构建代理对象时，考虑接口添加、空间说说秒赞源码回调函数配置等，最终通过`createProxy()`方法生成可调用的代理对象。

       通过这一系列复杂而有序的过程，`wrapIfNecessary()`方法实现了根据特定条件判断是否创建代理对象，并构建出适用于面向切面编程场景的代理对象，进而增强了应用程序的功能性和灵活性。

如何理解Spring的AOP？

       Spring的AOP面向切面编程，就是横向的，比如程序运行时都要建日志，相当于SQL的触发器。

       Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) è½»é‡çº§å¼€æºæ¡†æž¶ã€‚

       Spring特点：

       1、方便解耦，简化开发

       é€šè¿‡Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

       2、AOP编程的支持

       é€šè¿‡Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

       3、声明式事务的支持

       åœ¨Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

       4、方便程序的测试

       å¯ä»¥ç”¨éžå®¹å™¨ä¾èµ–的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如:Spring对Junit4支持，可以通过注解方便的测试Spring程序。

       5、方便集成各种优秀框架

       Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持。

       6、降低Java EE API的使用难度

       Spring对很多难用的Java EE API(如JDBC，JavaMail，远程调用等)提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

       7、Java 源码是经典学习范例

       Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

springaop原理

       åŽŸç†ï¼šsping aop是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP 可以说也是这种目标的一种实现。

       å…¶åŽŸç†çš„相关技术：

       AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。AOP（这里的AOP指的是面向切面编程思想，而不是Spring AOP）主要的的实现技术主要有Spring AOP和AspectJ。

        AspectJ的底层技术是静态代理，即用一种AspectJ支持的特定语言编写切面，通过一个命令来编译，生成一个新的代理类，该代理类增强了业务类，这是在编译时增强，相对于下面说的运行时增强，编译时增强的性能更好。

       Spring AOP采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，对于动态代理技术，Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。

       JDK动态代理只能为接口创建动态代理实例，而不能对类创建动态代理。需要获得被目标类的接口信息（应用Java的反射技术），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理类的构造函数，利用构造函数生成动态代理类的实例对象，在调用具体方法前调用invokeHandler方法来处理。

谈谈对springaop的理解？

       Spring的AOP如何理解,在业务里的作用是什么?

       1、AOP编程的支持通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

       2、AOP：面向切面，是一种编程思想，OOP的延续。将系统中非核心的业务提取出来，进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。

       3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。

       Spring中的AOP怎么理解

       åˆ‡é¢ç¼–程，就是在你项目原有的功能基础上，通过AOP去添加新的功能，这些功能是建立在原有功能的基础上的，而且原有的功能并不知道你已经添加了新的功能。

       IoC就是对象的创建，依赖都由Spring及配置文件控制；AOP就是统一的给一些类似的方法加上同样的功能，比如日志，事务。Spring框架是一个分层架构，由7个定义良好的模块组成。

       åœ¨AOP中有几个概念：—方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。

       AOP：面向切面，是一种编程思想，OOP的延续。将系统中非核心的业务提取出来，进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。

       SpringAOP是编程框架AOP是OOP的延续，是AspectOrientedProgramming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

       æœ¬äººæš‚且把Spring中的AOP理解成一种方法的拦截器（可能有所片面，主要是方便理解）。个人通俗理解，就好比你去自动取款机取钱，边上装了个摄像头在监视着。

请你谈谈对spring的理解?

       spring的基本意思是“春天，春季”，引申可指“青春”。spring还可作“跳”“跳跃”解，引申可指“弹簧，发条”“泉水”，是可数名词。spring跟带有延续性的介词时，前面要加定冠词the。

       Spring是一个开放源代码的J2EE应用程序框架，由RodJohnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweightcontainer）。

       Spring框架概述Core封装包是框架的最基础部分，提供IoC和依赖注入特性。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

简述你对Spring框架IOC和AOP的理解。

       IoC就是对象的创建，依赖都由Spring及配置文件控制；AOP就是统一的给一些类似的方法加上同样的功能，比如日志，事务。Spring框架是一个分层架构，由7个定义良好的模块组成。

       ioc就是控制反转，可以理解为当spring被加载启动后，在spring配置的bean都会被这个框架预先实例化（作用于为单例），然后在你需要的这个对象的时候直接添加注入就可以调用这个对象了这样可以大大降低了类之间的耦合度。

       AOP：面向切面，是一种编程思想，OOP的延续。将系统中非核心的业务提取出来，进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。

       AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

       æˆ‘的理解ioc就是自动创建对象的过程。以前是随时用，随时new，用了ioc就将这个事件交给程序，自动动创建对象。aop就是事物的控制，比如一个提交操作没有完成，则自动回滚。

       è¿™ä¸ªç¬¬ä¸‰æ–¹æŒ‡çš„就是Spring的容器。IoC另解，依赖注入（DependencyInjection），调用类对被调用类的依赖关系由第三方注入，以移除调用类对被调用类的引用。

张图，剖析 Spring AOP 源码，小白居然也能看懂，大神，请收下我的膝盖！

       本文将简要介绍AOP（面向切面编程）的基础知识与使用方法，并深入剖析Spring AOP源码。首先，我们需要理解AOP的基本概念。

       1. **基础知识

**

       1.1 **什么是AOP？

**

       AOP全称为Aspect Oriented Programming，即面向切面编程。AOP的思想中，周边功能（如性能统计、日志记录、事务管理等）被定义为切面，核心功能与切面功能独立开发，然后将两者“编织”在一起，这就是AOP的核心。

       AOP能够将与业务无关、却为业务模块共同调用的逻辑封装，减少系统重复代码，降低模块间的耦合度，有利于系统的可扩展性和可维护性。

       1.2 **AOP基础概念

**

       解释较为官方，以下用“方言”解释：AOP包括五种通知分类。

       1.3 **AOP简单示例

**

       创建`Louzai`类，添加`LouzaiAspect`切面，并在`applicationContext.xml`中配置。程序入口处添加`"睡觉"`方法并添加前置和后置通知。接下来，我们将探讨Spring内部如何实现这一过程。传奇 合区工具 源码

       1.4 **Spring AOP工作流程

**

       为了便于理解后面的源码，我们将整体介绍源码执行流程。整个Spring AOP源码分为三块，结合示例进行讲解。

       第一块是前置处理，创建`Louzai`Bean前，遍历所有切面信息并存储在缓存中。第二块是后置处理，创建`Louzai`Bean时，主要处理两件事。第三块是执行切面，通过“责任链+递归”执行切面。

       2. **源码解读

**

       注意：Spring版本为5.2..RELEASE，否则代码可能不同！这里，我们将从原理部分开始，逐步深入源码。

       2.1 **代码入口

**

       从`getBean()`函数开始，进入创建Bean的逻辑。

       2.2 **前置处理

**

       主要任务是遍历切面信息并存储。

       这是重点！请务必注意！获取切面信息流程结束，后续操作都从缓存`advisorsCache`获取。

       2.2.1 **判断是否为切面

**

       执行逻辑为：判断是否包含切面信息。

       2.2.2 **获取切面列表

**

       进入`getAdvice()`，生成切面信息。

       2.3 **后置处理

**

       主要从缓存拿切面，与`Louzai`方法匹配，创建AOP代理对象。

       进入`doCreateBean()`，执行后续逻辑。

       2.3.1 **获取切面

**

       首先，查看如何获取`Louzai`的切面列表。

       进入`buildAspectJAdvisors()`，方法用于存储切面信息至缓存`advisorsCache`。随后回到`findEligibleAdvisors()`，从缓存获取所有切面信息。

       2.3.2 **创建代理对象

**

       有了`Louzai`的切面列表，开始创建AOP代理对象。

       这是重点！请仔细阅读！这里有两种创建AOP代理对象方式，我们选择使用Cglib。

       2.4 **切面执行

**

       通过“责任链+递归”执行切面与方法。

       这部分逻辑非常复杂！接下来是“执行切面”最核心的逻辑，简述设计思路。

       2.4.1 **第一次递归

**

       数组第一个对象执行`invoke()`，参数为`CglibMethodInvocation`。

       执行完毕后，继续执行`CglibMethodInvocation`的`process()`。

       2.4.2 **第二次递归

**

       数组第二个对象执行`invoke()`。

       2.4.3 **第三次递归

**

       数组第三个对象执行`invoke()`。

       执行完毕，退出递归，查看`invokeJoinpoint()`执行逻辑，即执行主方法。回到第三次递归入口，继续执行后续切面。

       切面执行逻辑已演示，直接查看执行方法。

       流程结束时，依次退出递归。

       2.4.4 **设计思路

**

       这部分代码研究了大半天，因为这里不是纯粹的责任链模式。

       纯粹的责任链模式中，对象内部有一个自身的`next`对象，执行当前对象方法后，启动`next`对象执行，直至最后一个`next`对象执行完毕，或中途因条件中断执行，责任链退出。

       这里`CglibMethodInvocation`对象内部无`next`对象，通过`interceptorsAndDynamicMethodMatchers`数组控制执行顺序，依次执行数组中的对象，直至最后一个对象执行完毕，责任链退出。

       这属于责任链，实现方式不同，后续会详细剖析。下面讨论类之间的关系。

       主对象为`CglibMethodInvocation`，继承于`ReflectiveMethodInvocation`，`process()`的核心逻辑在`ReflectiveMethodInvocation`中。

       `ReflectiveMethodInvocation`的`process()`控制整个责任链的执行。

       `ReflectiveMethodInvocation`的`process()`方法中，包含一个长度为3的数组`interceptorsAndDynamicMethodMatchers`，存储了3个对象，分别为`ExposeInvocationInterceptor`、`MethodBeforeAdviceInterceptor`、`AfterReturningAdviceInterceptor`。

       注意！这3个对象都继承了`MethodInterceptor`接口。

       每次`invoke()`调用时，都会执行`CglibMethodInvocation`的`process()`。

       是否有些困惑？别着急，我将再次帮你梳理。

       对象与方法的关系：

       可能有同学疑惑，`invoke()`的参数为`MethodInvocation`，没错！但`CglibMethodInvocation`也继承了`MethodInvocation`，可自行查看。

       执行逻辑：

       设计巧妙之处在于，纯粹的责任链模式中，`next`对象需要保证类型一致。但这里3个对象内部没有`next`成员，不能直接使用责任链模式。怎么办呢？就单独设计了`CglibMethodInvocation.process()`，通过无限递归`process()`实现责任链逻辑。

       这就是我们为什么要研究源码，学习优秀的设计思路！

       3. **总结

**

       本文首先介绍了AOP的基本概念与原理，通过示例展示了AOP的应用。之后深入剖析了Spring AOP源码，分为三部分。

       本文是Spring源码解析的第三篇，感觉是难度较大的一篇。图解代码花费了6个小时，整个过程都沉浸在代码的解析中。

       难度不在于抠图，而是“切面执行”的设计思路，即使流程能走通，将设计思想总结并清晰表达给读者，需要极大的耐心与理解能力。

       今天的源码解析到此结束，有关Spring源码的学习，大家还想了解哪些内容，欢迎留言给楼仔。

SpringIoc和Aop底层原理

       文章内容

       本文深入解析Spring框架中的Ioc和Aop底层原理。

       首先，Ioc（依赖注入）通过Spring配置文件实现对象的创建，而不是传统的new方式。实现Ioc，主要有两种方法：配置文件和注解。Ioc底层原理包括：使用xml配置文件创建类，通过dom4j解析配置，工厂设计模式配合使用，以及反射技术。通过Ioc，开发者只需修改bean配置属性，就能更换UserService类，有效降低类间的耦合度。

       与DI（依赖注入）相比，Ioc更加关注控制反转，将对象创建权交由Spring管理；而DI则着重于在对象内部注入属性值。Ioc与DI相辅相成，DI必须在Ioc的基础上进行操作，即先创建对象后进行属性注入。

       文章接下来解释了Spring整合web项目原理，包括加载Spring核心配置文件、服务器启动时动态加载配置和创建对象，以及使用ServletContext和监听器实现这一过程。具体操作包括为每个项目创建ServletContext对象、监听对象创建事件，并在contextInitialized()方法中加载配置文件和创建对象，最后将对象存储在ServletContext域对象中以便于获取。

       Aop（面向切面编程）在Spring中实现，通过动态代理扩展功能，无需修改源代码。动态代理分为两种情况：有接口时使用jdk动态代理，无接口时使用cglib动态代理。Aop提供多种增强类型，包括前置、后置、异常、最终和环绕增强。

       文章最后建议读者关注学习资源，通过扫描二维码获取更多知识和学习资料。

spring aop代理对象创建以及调用invoke源码

       深入解析Spring AOP代理对象创建及调用invoke源码

       一、代理对象创建与invoke源码概览

       1.1 代理对象创建源码概览

       Spring AOP代理对象的创建时机主要在实例化后或初始化后。具体流程涉及BeanPostProcessor.postProcessAfterInitialization()方法。正常情况下，代理对象创建与单例池内的代理对象一致，确保方法调用实际指向代理对象。

       1.2 invoke执行目标方法源码概览

       目标对象方法调用后，因为代理对象存储于单例池，实际调用的是代理对象的增强方法。这种方式实现了方法调用的动态代理。

       1.3 exposeProxy = true使用说明

       1.3.1 不使用(exposeProxy = true)

       不使用配置时，目标方法内部调用被拦截增强的方法，不会再次触发AOP。

       1.3.2 使用(exposeProxy = true)

       启用此配置后，执行目标方法时，AOP增强将再次激活，从而触发重复执行。

       1.3.3 cglib与JDK代理区别

       cglib通过继承实现代理，方法调用指向代理对象，因此内嵌方法会重复调用增强逻辑；

       JDK代理通过反射，方法调用直接指向目标对象，内嵌方法不会重复调用。

       关于Spring中cglib不会重复调用的解释：测试表明，使用Spring5.版本，强制使用cglib配置时，案例中方法调用与代理对象方法调用之间并无重复，原因是Spring调用的是目标方法而非代理对象的方法。

       二、代理对象创建及invoke源码分析图

       代理创建流程始于@EnableAspectJAutoProxy注解注册的AspectJAutoProxyRegistrar，此注册器在解析import注解时执行registerBeanDefinitions方法。该方法注册了在bean实例化前调用的InstantiationAwareBeanPostProcessor类型的bean后置处理器，此处理器在实例化前解析AOP，非循环依赖在初始化后调用postProcessAfterInitialization()创建动态代理。

       匹配Advisor集合：首先筛选Advisor列表，匹配规则涉及类级别和方法级别的筛选，通过Aspect匹配实现。同时，Advisor排序确保调用顺序遵循通知类型。创建代理对象遵循ProxyTargetClass参数与目标类接口的配置，选择JDK或cglib动态代理。

       代理方法调用：由于存储的是代理对象，方法调用实际指向代理。exposeProxy = true配置下，代理对象暴露到线程变量中。代理对象执行方法调用遵循责任链模式，按顺序执行前置、目标方法、后置等通知。