likes
comments
collection
share

Spring AOP 类功能介绍

作者站长头像
站长
· 阅读数 24

Spring AOP 类功能介绍

一、org.aopalliance.intercept 包

  • 一、拦截器接口

    • 1、Interceptor：所有拦截器的 最最基础接口
    • 2、ConstructorInterceptor： 构造方法拦截器
    • 3、MethodInterceptor： 方法拦截器

  • 二、方法描述（方法调用）

    • 1、Invocation： 所有运行时的方法调用 最最基础接口
    • 2、ConstructorInvocation： 构造方法调用
    • 3、MethodInvocation： 方法调用

  • 三、Joinpoint 连接点接口

    • 该接口代表了一个通用的运行时连接点。

二、org.springframework.aop.scope 包

作用域包

  • 一、ScopedObject

    • 1、作用：

      用于作用域对象的AOP引介接口；

      从ScopedProxyFactoryBean创建的对象可以强制转换到此接口，从而能够访问原始目标对象并以编程方式删除目标对象。

      Spring的Bean是有scope属性的，表示bean的生存周期。scope的值有： prototype、singleton、session、request。

    • 2、实现类

      DefaultScopedObject：设置 目标源name 和 beanFactory

  • 二、ScopedProxyFactoryBean

    • 该类创建的代理工厂Bean，主要是用于作用域对象的操作。

  • 三、ScopedProxyUtils

    • 辅助类；创建作用域代理的功能性类。
    • 主要被ScopedProxyBeanDefinitionDecorator and ClassPathBeanDefinitionScanner 使用

三、org.springframework.aop.target 包

介绍：

​ TargetSource：目标对象

​ 包含连接点的对象。也被称作被通知或被代理对象。

​ TargetSource被用于获取当前MethodInvocation（方法调用）所需要的target（目标对象），这个target通过反射的方式被调用（如：method.invoke(target,args)）。换句话说，proxy（代理对象）代理的不是target，而是TargetSource。

为什么Spring AOP代理不直接代理target，而需要通过代理TargetSource（target的来源，其内部持有target），间接代理target呢？

​ 通常情况下，一个proxy（代理对象）只能代理一个target，每次方法调用的目标也是唯一固定的target。但是，如果让proxy代理TargetSource，可以使得每次方法调用的target实例都不同（当然也可以相同，这取决于TargetSource实现）。

​ 这种机制使得方法调用变得灵活，可以扩展出很多高级功能，如：target pool（目标对象池）、hot swap（运行时目标对象热替换）等等。

​ TargetSource组件本身与Spring IoC容器无关，target的生命周期不一定是受spring容器管理的，我们以往的XML中的AOP配置，只是对受容器管理的bean而言的，我们当然可以手动创建一个target，同时使用Spring的AOP框架（而不使用IoC容器）。

  • 一、TargetClassAware：

    目标源的最顶层接口；用于在代理后面公开目标类的最小接口；

    由AOP代理对象和代理工厂（通过org.springframework.AOP.framework.Advised）以及TargetSources实现。

    这里主要讨论目标源，所以往下走 TargetSource 接口。

  • 二、TargetSource

    目标源的顶层接口；

    目标源：TargetSource(目标源)是被代理的target(目标对象)实例的来源。

  • 三、AbstractBeanFactoryBasedTargetSource

    该类实现 TargetSource 的同时实现 BeanFactoryAware；

    而，BeanFactoryAware是Spring Bean工厂，可以将 AbstractBeanFactoryBasedTargetSource，通过实现BeanFactoryAware#setBeanFactory()方法将AbstractBeanFactoryBasedTargetSource(目标源)的beanFactory委托给Spring管理。

    即：此类目标源基于IoC容器实现，也就是说target目标对象可以通过beanName从容器中获去。

    下面1~8是该基类的子类：

    • 1、AbstractPrototypeBasedTargetSource

      动态目标源的基类，用以创建新的原型bean实例，以支持池或每次调用新实例策略。

      此类TargetSources(数据源)必须在BeanFactory中运行，因为它需要调用getBean方法来创建新的原型实例。(注意这里调用getBean())

      因此，这个基类扩展了AbstractBeanFactoryBasedTargetSource。继承该类的子类：(PrototypeTargetSource，ThreadLocalTargetSource，AbstractPoolingTargetSource)都需要调用getBean方法来创建新的原型实例。

      子类：

      • ①、PrototypeTargetSource

        prototype：原型模式，获取原型模式的目标源； 该类的定义：为每个请求创建目标bean的新实例，在释放时(在每个请求之后)销毁每个实例。

      • ②、ThreadLocalTargetSource

        • Ⅰ、对象池的替代方案；利用ThreadLocal可以使每个线程都有自己的目标副本。不存在对目标的争夺。
        • Ⅱ、ThreadLocalTargetSourceStats：仅仅是ThreadLocalTargetSource的一个接口。

      • ③、AbstractPoolingTargetSource

        • Ⅰ、该类是 目标源线程池的基础抽象类；

        • Ⅱ、子类：CommonsPool2TargetSource

          ​ 目标源线程池，利用 Apache Commons2 Pool实现线程池。

        • Ⅲ、PoolingConfig是AbstractPoolingTargetSource的一个接口

          ​ 仅仅是获取线程值的一些参数配置信息。

    • 2、LazyInitTargetSource

      ​ 懒加载目标源。通过配置bean为 lazy-init="true"，实现懒加载。

    • 3、SimpleBeanTargetSource

      ​ 从其包含的Spring BeanFactory中刷新获取指定的目标bean；

      ​ 可以获得任何类型的目标bean：singleton、scoped、prototype。通常用于有范围的bean。

    • 4、EmptyTargetSource

      ​ 静态目标源，当不存在target目标对象，或者甚至连targetClass目标类都不存在（或未知）时，使用此类实例。

    • 5、HotSwappableTargetSource

      ​ 该类的主要作用可能就是 swap()方法，用于新，旧目标对象的交换。

    • 6、AbstractLazyCreationTargetSource

      ​ 懒加载目标对象创建的基础抽象类；

      ​ 具体的创建由用户通过实现createObject()方法来控制；首次访问代理时，此TargetSource将调用此方法。

      （懒加载，懒加载，使用的时候在创建）

    • 7、AbstractRefreshableTargetSource

      • Ⅰ、它封装了一个可刷新的目标对象。子类可以确定是否需要刷新，并且需要提供新的目标对象。

      • Ⅱ、BeanFactoryRefreshableTargetSource

      ​ 作为 AbstractRefreshableTargetSource的子类从BeanFactory获取刷新的目标beans。

      ​ 可以子类化以覆盖requiresRefresh()以防止不必要的刷新。

      • Ⅲ、Refreshable

        ​ AbstractRefreshableTargetSource实现的一个接口；获取刷新对象的一些信息，如：刷新时间，刷新次数。

    • 8、SingletonTargetSource

      • 该目标源获取的目标对象是单例的，成员变量target缓存了目标对象，每次getTarget()都是返回这个对象。

四、org.springframework.aop.interceptor 包

介绍：

​ 该包中作为拦截器的类都是 MethodInterceptor 的子类。

​ (下面只是拦截器包中的类，可以作为拦截器，按类别不同也分散在了不同的包中：

​ 如：各种通知：AfterReturningAdviceInterceptor，AspectJAfterAdvice，AspectJAfterThrowingAdvice，AspectJAroundAdvice 其实通知也可以叫做拦截器)

  • 一、AbstractTraceInterceptor

    • 1、作用：

      ​ 用于跟踪的 MethodInterceptor接口的基础实现类。

      ​ 默认情况下，日志消息会写入拦截器类的日志，而不是被截获的类的日志。

    • 2、子类：

      • ①、AbstractMonitoringInterceptor

        • Ⅰ、作用：监视拦截器（如性能监视器）的基类。
        • Ⅱ、两个子类：
          • JamonPerformanceMonitorInterceptor ：不知道啥玩意，无关紧要。
          • PerformanceMonitorInterceptor：用于性能监控的简单AOP Alliance MethodInterceptor。此拦截器对被拦截的方法调用没有影响。

      • ②、CustomizableTraceInterceptor

        ​ 作用：自定义 允许使用占位符进行高度定制的方法级跟踪。

      • ③、SimpleTraceInterceptor

        • Ⅰ、作用：可以在链中引入，以显示有关被拦截方法调用的详细跟踪信息，以及方法入口和方法出口信息。

        • Ⅱ、子类：

          • DebugInterceptor

            ​ 仅调试时使用。

  • 二、AsyncExecutionInterceptor

    • 1、异步执行拦截器
    • 2、会用到：
      • AsyncUncaughtExceptionHandler： 异步异常处理器接口；
      • SimpleAsyncUncaughtExceptionHandler：异步异常处理器的实现。

  • 三、ConcurrencyThrottleInterceptor

    阻止并发访问的拦截器，在达到指定的并发限制时阻止调用。

  • 四、ExposeInvocationInterceptor

    将当前MethodInvocation公开为线程本地对象的拦截器。

五、org.springframework.aop.framework包

5.1 当前包中的类

  • 代理对象创建工具：(这里就是创建代理方式的两种方式类，JDK代理和CGLIB代理)

  • AopProxy：

    • 作用：AOP代理的创建，两种方式：JDK代理和CGLIB代理；
    • 下面有三个实现类：
      • 1、CglibAopProxy : CGLIB代理的基类，ObjenesisCglibAopProxy 是 CglibAopProxy的子类；
      • 2、JdkDynamicAopProxy : JDK代理

  • AopProxyFactory：

    • 1、AOP代理工厂，创建AOP代理，该类中只有一个方法：createAopProxy(AdvisedSupport config)

      该方法中会判断使用JDK代理还是CGLIB代理。

    • 2、该接口的默认实现类：

      • DefaultAopProxyFactory

上面的 创建代理，代理工厂已经完全解耦，只关注传过去的 赤裸裸的方法了；

下面这几个类是对AOP代理过程中 配置的一些属性，配置的处理。

  • ProxyConfig：

    • 是下面几个的祖宗；
    • 用于创建代理的配置的便利超类，封装了代理的一些配置属性；如：proxyTargetClass，optimize，exposeProxy等。

  • ProxyCreatorSupport：

    • 1、作用：
      • 代理工厂的基类。方便访问可配置的AOPProxy工厂。
      • 因为该类里有一个AOP代理工厂属性： aopProxyFactory；可以通过构造方法创建 AOP的代理工厂。
    • 2、两个子类：
      • ProxyFactory：代理工厂；
      • ProxyFactoryBean：看着挺重要的，还不知道怎么用！！！ 看留在这里。
    • 3、父类：
      • AdvisedSupport
        • AOP代理配置管理器的基类，该类本身不是AOP代理。
        • 只是将属性：Advices和advisor放在了该类去管理，创建代理的工作还是在子类，并不在此类中。

5.2 org.springframework.aop.framework.adapter包

作用：

​ 该包主要的作用顾名思义，适配器！！！

​ 将给定的通知类型，通过适配器封装成对应的拦截器；

​ 那么，这个包的类就分成了3类。

  • 一、Advisor适配器

  • AdvisorAdapter 接口，下面的实现：

    • 1、MethodBeforeAdviceAdapter 前置方法通知适配器
    • 2、AfterReturningAdviceAdapter 后置返回通知适配器
    • 3、ThrowsAdviceAdapter 异常通知适配器

  • 二、Advisor适配器将Advisor封装成的拦截器：

    • MethodBeforeAdviceInterceptor，AfterReturningAdviceInterceptor，ThrowsAdviceInterceptor：这三个拦截器都实现类 MethodInterceptor方法拦截器接口，目的是为了实现 invoke方法。
    • 这里适配器接口的目的，是将得到的 Advice通知 包装成对应的拦截器，如：
      • 1、MethodBeforeAdviceAdapter 将advice包装成 MethodBeforeAdviceInterceptor
      • 2、AfterReturningAdviceAdapter 将advice包装成 AfterReturningAdviceInterceptor
      • 3、ThrowsAdviceAdapter 将advice包装成 ThrowsAdviceInterceptor

  • 三、注册表工具类：

    AdvisorAdapterRegistry：适配器注册表接口；

    DefaultAdvisorAdapterRegistry：默认的适配器注册表实现；

    GlobalAdvisorAdapterRegistry：全局适配器注册表

    Advisor(增强器)的适配器(Adapter)注册表工具：

    • 1、AdvisorAdapterRegistry (增强器的适配器的)注册表接口）

    • 2、DefaultAdvisorAdapterRegistry：默认的实现类；注册三种类型的适配器!

    • 3、GlobalAdvisorAdapterRegistry：

      全局的 Advisor适配器注册表，通过 DefaultAdvisorAdapterRegistry创建的实例，获取Advisor适配器注册表。

  • 四、AdvisorAdapterRegistrationManager

    Advisor适配器注册表管理器，将用户自定义的Advisor适配器注册表加入到 advisorAdapterRegistry适配器注册列表中去。

  • 五、异常 UnknownAdviceTypeException

    当使用了 Advisor or Advice不支持的类型时，抛出该异常。

5.3 org.springframework.aop.framework.autoproxy 包

  • 一、目标源创建者

    • 1、TargetSourceCreator 接口
      • 为给定的bean创建特殊的目标源 (这里的目标源可以是：org.springframework.aop.target包中相应的目标源类型，如：池化目标源)；
      • 该接口的实现类可以为特定bean创建特殊的目标源；
      • 子类实现：
        • ①、LazyInitTargetSourceCreator：懒加载初始化目标源创建者
        • ②、QuickTargetSourceCreator：使用bean名称前缀创建三种著名的TargetSource类型

  • 二、自动代理创建者

    • AbstractAutoProxyCreator

      • 作为自动代理创建者的基础类；实现 SmartInstantiationAwareBeanPostProcessor；

      • 因为，SmartInstantiationAwareBeanPostProcessor继承了BeanPostProcessor，所以，这里 重写postProcessAfterInitialization()方法，处理被标识的bean（需要被代理的bean）。

      • 子类实现：

        • 1、AbstractAdvisorAutoProxyCreator：

          • 作用：增强器 自动代理创建者，我们要知道，增强器是通知和切入点的结合。

          • 子类：

            • ①、DefaultAdvisorAutoProxyCreator：

              • 增强器 自动代理创建者的默认实现。

            • ②、InfrastructureAdvisorAutoProxyCreator

              • 自动代理创建者只考虑infrastructure Advisor bean，忽略任何应用程序定义的Advisors。

            • ③、AspectJAwareAdvisorAutoProxyCreator (在org.springframework.aop.aspectj.autoproxy包)

              • 当多条通知来自同一个aspect(切面)时，它公开AspectJ的调用上下文并理解AspectJ的通知优先级规则；

              • 子类实现：

                • AnnotationAwareAspectJAutoProxyCreator (在org.springframework.aop.aspectj.annotation包中)

                  注解方式自动代理创建者

        • 2、BeanNameAutoProxyCreator

          ​ 自动代理创建者，通过名称列表识别要代理的bean。检查是否直接匹配“xxx*”和“*xxx”。

    • BeanFactoryAdvisorRetrievalHelper：

      • 从BeanFactory检索标准Spring Advisors的工具类，用于自动代理。

    • ProxyCreationContext：

      • 当前代理创建上下文的持有者，由 auto-proxy创建者暴露，如：AbstractAdvisorAutoProxyCreator

    • AutoProxyUtils：

      • 自动代理感知组件的实用程序。主要用于框架内的内部使用。

六、org.springframework.aop.support 包

一、方法匹配器

MethodMatcher 从该接口开始

  • 1、静态方法匹配器
    • StaticMethodMatcher ：静态方法匹配器
  • 2、动态方法匹配器
    • DynamicMethodMatcher：为动态方法匹配器提供方便的抽象超类，动态方法匹配器在运行时需要关心参数。
  • 3、注解方法匹配器
    • AnnotationMethodMatcher： (该类继承了 StaticMethodMatcher)；用于查找方法上存在的特定Java 5注释（检查调用接口上的方法（如果有）和目标类上的相应方法）

二、类过滤器

ClassFilter 从该接口开始；(切入点Pointcut或引介Introduction)与给定目标类集的匹配的过滤器。可以用作切入点的一部分，也可以用于IntroductionAdvisor的整个目标。

  • 1、TypePatternClassFilter : 基于AspectJ的类型匹配实现；
  • 2、AnnotationClassFilter : 通过检查目标类是否存在指定的注解，决定是否匹配；
  • 3、RootClassFilter : 通过判断目标类是否是指定类型（或其子类型），决定是否匹配；
  • 4、TrueClassFilter ：
    • 这是最简单实现，matches方法总会返回true。
    • 此类设计使用了单例模式，且其对象引用直接被在ClassFilter接口中声明成了常量。

三、方法匹配器、类过滤器的 交、差集匹配类

  • 1、MethodMatchers 方法匹配器 交union、差intersection匹配
  • 2、ClassFilters 类过滤器 交union、差intersection匹配

四、切入点

Pointcut：从该接口开始

★★★切入点由类过滤器(ClassFilter)和方法匹配器(MethodMatcher)组成。★★★

这些基本术语和切入点本身都可以组合起来构建组合（例如：通过org.springframework.aop.support.ComposablePointcut）。

  • 1、TruePointcut： 方法过滤器，类过滤器返回的参数都是真。

  • 2、AnnotationMatchingPointcut： 查找类或方法上存在的特定Java 5注解的简单切入点。

  • ★3、ComposablePointcut：可组合的切入点；通过里面的方法构造可以看出来，其实就是将类过滤器(ClassFilter)和方法匹配器(MethodMatcher)进行组合。

  • 4、ControlFlowPointcut：控制流切入点

  • ★5、StaticMethodMatcherPointcut：

    • 当我们想要强制子类实现MethodMatcher接口，但子类想要成为切入点时，就可以以此类作为一个超类。
    • 该类继承了StaticMethodMatcher，并实现了Pointcut。

  • ★6、DynamicMethodMatcherPointcut：

    • 当我们想要强制子类实现MethodMatcher接口，但子类想要成为切入点时，可以用此类作为超类。
    • 该类实现了 DynamicMethodMatcher 和 Pointcut切入点

  • ★7、ExpressionPointcut：该接口将由使用字符串表达式的切入点实现

    • ①、AbstractExpressionPointcut：表达式切入点的抽象超类，提供位置和表达式属性。
    • ②、AspectJExpressionPointcut：子类实现；就是为了处理：execution(void .(..)) ；切入点表达式值是AspectJ表达式。

  • 8、NameMatchMethodPointcut：用于简单方法名匹配的切入点bean，作为regexp模式的替代。

  • 9、AbstractRegexpMethodPointcut

    • 作用：

      正则表达式切入点bean的基础抽象类。

      如：.*get.*
	 与 com.mycom.Foo.getBar(). 匹配
	 与 get.* 则不会

    • 子类实现：

      • JdkRegexpMethodPointcut：基于java.util.regex包的正则表达式切入点。

五、Pointcuts 组合切入点的类

​ 交集union、差集intersection方式组合切入点

六、增强器

PointcutAdvisor 该接口为：连接点增强器的超级接口

下面是子类实现。

  • 1、StaticMethodMatcherPointcutAdvisor
    • 为增强器提供方便的基类，这些增强器也是静态切入点。
  • 2、AbstractPointcutAdvisor
  • ①、作用：
    • PointcutAdvisor实现的抽象基类。可以子类化以返回特定的切入点/通知 或 可自由配置的切入点/通知。
    • 该类里面只有一个属性：order 优先级
  • ②、子类
    • (1)、 AbstractGenericPointcutAdvisor
      • 作用：通用的切入点增强器，里面只有一个属性 advice 通知
      • 子类：
        • Ⅰ、DefaultPointcutAdvisor
          • 默认的实现；
          • 它可以用于任何切入点和通知类型，除了引介。通常不需要对该类进行子类化，也不需要实现自定义增强器；
          • 该类中只有一个属性 pointcut 切入点。
        • Ⅱ、AspectJExpressionPointcutAdvisor
          • 可用于任何AspectJ切入点表达式。
        • Ⅲ、NameMatchMethodPointcutAdvisor
          • 方便的名称匹配方法切入点类，该切入点包含通知，使它们成为增强器。
        • Ⅳ、RegexpMethodPointcutAdvisor
          • 正则表达式方法的类，这些切入点持有一个Advice，可使他们成为一个增强器。
    • (2)、AbstractBeanFactoryPointcutAdvisor
      • 作用：基于BeanFactory的抽象PointcutAdvisor，允许将任何通知配置为对BeanFactory中通知bean的引用。
      • 子类：
        • Ⅰ、DefaultBeanFactoryPointcutAdvisor
          • 这个是在当期 aop support包中的默认实现。
        • Ⅱ、BeanFactoryCacheOperationSourceAdvisor
          • (在 spring-context工程中 )
          • 由CacheOperationSource驱动的Advisor，用于包含可缓存方法的缓存通知bean。
        • Ⅲ、BeanFactoryJCacheOperationSourceAdvisor
          • 由JCacheOperationSource驱动的Advisor，用于包含可缓存方法的缓存通知bean。
        • Ⅳ、BeanFactoryTransactionAttributeSourceAdvisor
          • 由TransactionAttributeSource驱动的Advisor，用于包含事务性方法的事务通知bean。

七、引介增强器

也在这个包里面介绍了吧！！！

引介增强是一种比较特殊的增强类型，它不是在目标方法周围织入增强，而是为目标创建新的方法和属性，所以它的连接点是类级别的而非方法级别的。

通过引介增强我们可以为目标类添加一个接口的实现即原来目标类未实现某个接口,那么通过引介增强可以为目标类创建实现某接口的代理。

可以看 a-spring-test-demo中 aopintroduction 包中的demo 对应引介增强器的使用。

  • 1、IntroductionInfo

    引介信息接口；提供描述引介所需信息的接口；IntroductionAdvisors必须实现这个接口。

    子类实现：

    • IntroductionInfoSupport

      支持IntroductionInfo的实现。

      允许子类方便地添加来自给定对象的所有接口，并防止不应添加的接口。还允许查询所有引介的接口。

  • 2、IntroductionInterceptor

    • 作用：引介拦截器接口。
    • 父类：DynamicIntroductionAdvice：动态引介通知接口
    • 子类实现：

      • ①、DelegatingIntroductionInterceptor

        • 子类只需要扩展这个类，并实现自己要引介的接口。
        • 如：我们 a-spring-test-demo 工程中的 aopintroduction包中的 CustomIntroductionInterceptor类；就是 我们自定义的引介。

      • ②、DelegatePerTargetObjectIntroductionInterceptor

        • 该类与DelegatingIntroductionInterceptor的不同之处在于，该类的一个实例可用于通知多个目标对象，每个目标对象都有自己的委托（而DelegatingIntroductionInterceptor共享同一委托，因此所有目标的状态都相同）。

  • 3、IntroductionAdvisor：

    • 作用：为执行一个或多个 AOP引介 的增强器提供超级接口。这个接口不能直接实现；子接口必须提供实现引介的通知类型。★
    • 实现类：
    • ①、DefaultIntroductionAdvisor：
      • 默认情况下适用于任何类的简单IntroductionAdvisor实现。
    • ②、DeclareParentsAdvisor：
      • 是在aop.aspectj包中；引介增强器委托给给定对象。实现DeclareParents注解的AspectJ注释样式行为。

  • 4、IntroductionAwareMethodMatcher

    ​ 引介织入方法匹配器，用于是引介类型的类中的方法匹配。

七、 org.springframework.aop.aspectj 包

这个包中的 annotation包，autoproxy包会揉在一块做归类。

一、通知类型

AbstractAspectJAdvice：

  • 作用：

    用于封装 (AspectJ切面 或 AspectJ注解的通知方法的) AOP Alliance包中 Advice接口的基础实现抽象类；

    这个是基类，通知处理的各种方法，属性等。

  • 子类实现： （对应5种通知类型）

    @see org.springframework.aop.aspectj.AspectJAroundAdvice
    @see org.springframework.aop.aspectj.AspectJMethodBeforeAdvice
    @see org.springframework.aop.aspectj.AspectJAfterAdvice
    @see org.springframework.aop.aspectj.AspectJAfterReturningAdvice
    @see org.springframework.aop.aspectj.AspectJAfterThrowingAdvice

二、3个工具类

  • 1、AspectJAopUtils

    就两个主要的方法，判断是否是前置通知，后置通知方法。

  • 2、AspectJProxyUtils

    有一个重要方法，在我们寻找可用的增强器，会有一步：extendAdvisors(eligibleAdvisors);

    AbstractAdvisorAutoProxyCreator#extendAdvisors(java.util.List)

    就是走到 该类中的 makeAdvisorChainAspectJCapableIfNecessary()方法，去为 拦截器链添加一个 ExposeInvocationInterceptor。

  • 3、AspectJAdviceParameterNameDiscoverer

    ParameterNameDiscoverer的实现，它尝试从切入点表达式、返回和抛出子句中推断出advice方法的参数名称。

三、AspectJExpressionPointcut

​ AspectJ 切入点表达式 处理类；这个类对应处理的是与：@AspectJ工具 .jar包对应的处理。

四、AspectJExpressionPointcutAdvisor

​ 对切入点增强器的 AspectJ表达式 (其实一个这样的实体)

五、AspectJPointcutAdvisor

​ AspectJ切入点增强器（其实像一个实体）；里面有 通知和切入点属性，以为增强器是通知和切入点的结合

六、两个接口

  • 1、AspectJPrecedenceInformation

    只是一个方便的接口，该接口中的方法 用于去获取 通知/增强器优先级排序所需的信息；

    因为通知/增强器的基础类AbstractAspectJAdvice已经实现了该类。

  • 2、InstantiationModelAwarePointcutAdvisor

    实例化增强器的接口，使通知/增强器封装成它的子类★InstantiationModelAwarePointcutAdvisorImpl；

    • 子类：

      • InstantiationModelAwarePointcutAdvisorImpl(在annotation包中)

        增强器/通知 大量的属性信息都有封装在这个实体实现里面了。

        里面的instantiatedAdvice属性，封装的是通知解析成对应通知类型的信息。

七、antoproxy包

  • 1、AspectJPrecedenceComparator

    切面中通知的比较器；用于比较通知的优先级的 工具类。

  • 2、AspectJAwareAdvisorAutoProxyCreator

    AbstractAdvisorAutoProxyCreator子类，当多条通知来自同一个aspect(切面)时，

    它公开AspectJ的调用上下文并处理AspectJ的通知优先级规则。

    AspectJPrecedenceComparator作用比较的工具类，在该类中得到应用。

八、切面实例工厂

(annotation包会顺带着在这里里面介绍，因为annotation包中的工厂类型，也是实现下面的切面实例工厂接口)

  • 1、AspectInstanceFactory

    ​ 切面实例工厂的基础接口

    • 子类：

    • ①、SimpleAspectInstanceFactory

      AspectInstanceFactory的实现，它为每个调用getAspectInstance()方法创建指定切面类的新实例。

    • ②、SingletonAspectInstanceFactory

      单例工厂：AspectInstanceFactory的实现，该实现由指定的单例对象支持，为每个调用getAspectInstance()方法的位置 返回相同的实例。

    • ③、元数据

      • Ⅰ、AspectMetadata：元数据类

      • Ⅱ、MetadataAwareAspectInstanceFactory：切面元数据实例工厂接口

        • ⑴、BeanFactoryAspectInstanceFactory

          ​ 该类也是 MetadataAwareAspectInstanceFactory 实现类

          ​ 主要是用于将 切面元数据和 BeanFactory关联

          • -> 子类
            • PrototypeAspectInstanceFactory：构建原型模式的切面实例工厂

        • ⑵、SimpleMetadataAwareAspectInstanceFactory

          ​ 该类 继承 SimpleAspectInstanceFactory 实现 MetadataAwareAspectInstanceFactory

          ​ 为元数据每调用一次getAspectInstance()方法都创建新的实例。

        • ⑶、SingletonMetadataAwareAspectInstanceFactory

          ​ 该类 继承 SingletonAspectInstanceFactory 实现 MetadataAwareAspectInstanceFactory

          ​ 为元数据每调用一次getAspectInstance()方法都返回相同的实例。

        • ⑷、LazySingletonAspectInstanceFactoryDecorator

          ​ 该类也是 MetadataAwareAspectInstanceFactory的实现；

          ​ 将切面元数据实例工厂包装成 懒加载的单例方式。

  • 2、AspectJAdvisorFactory

    ​ 切面增强器工厂

    • 子类实现：

      • ①、AbstractAspectJAdvisorFactory

        这里封装对通知的5种注解的基础定义。

        • 子类实现：

          ReflectiveAspectJAdvisorFactory：

          ​ 该类里面封装了大量的，获取切入点，通知、增强器，增强器列表这些方法。

  • 3、BeanFactoryAspectJAdvisorsBuilder

    上面1，2两组工厂都是封装各种类型的实例工厂；

    而，该类则是从BeanFactory的子类(上面的工厂)中检索出@AspectJ beans并基于这些beans构建增强器/通知列表；

    ★核心方法 buildAspectJAdvisors()，就是从工厂中捞出符合的通知类，构建增强器/通知列表。

  • 4、再再上层封装：★★★★

    • 最终来到我们 Spring AOP以注解方式 注册要处理AOP的类--->AnnotationAwareAspectJAutoProxyCreator

      封装了上面所有的作为下层的 切面增强器工厂和切面增强器BeanFactory建造着，再将所有的可以处理 AOP的信息都封装进入了：

      AspectJAdvisorFactory；BeanFactoryAspectJAdvisorsBuilder！！！

八、org.springframework.aop.config 包

其实 第七节要比这里重要~

一、节点实体

  • AdviceEntry 通知节点元素
  • AdvisorEntry 增强器节点元素
  • AspectEntry 切面节点元素
  • PointcutEntry 切入点节点元素

二、各种组合Definition

  • 1、AdvisorComponentDefinition

    增强器 ，它在 <aop:advisor>标签配置的 advisor bean definition和组件 definition基础架构之间架起了桥梁。

  • 2、AspectComponentDefinition

    切面 ， 持有切面的 definition属性信息，包括 它锁嵌套的其他切入点。

  • 3、PointcutComponentDefinition

    切入点， 持有切入点definition

三、装饰器

  • 1、AbstractInterceptorDrivenBeanDefinitionDecorator

    向生成的bean添加拦截器的基本实现。

  • 2、ScopedProxyBeanDefinitionDecorator

    BeanDefinitionDecorator负责解析<aop:scoped proxy/>标签的子类实现。

四、解析器

  • 1、SpringConfiguredBeanDefinitionParser

    负责解析<aop:spring-configured/>标签

  • 2、AspectJAutoProxyBeanDefinitionParser ★

    用于解析aspectj-autoproxy标签，支持自动应用组织中的@AspectJ风格方面

  • 3、ConfigBeanDefinitionParser ★

    <aop:config>标签对应的 BeanDefinitionParser 解析器

    解析该标签下的：pointcut 切入点，advisor 增强器，aspect 切面

五、初始化注册AOP

  • 1、AopConfigUtils

    注册AOP自动代理创建者，以及将配置的属性proxyTargetClass，exposeProxy绑定上去。

  • 2、AopNamespaceUtils

    这里其实是对 AOP代理方式，如：XML配置文件，注解方式注册的归纳，具体的方法还是在AopConfigUtils类中

  • 3、AopNamespaceHandler

    这里则是将config，aspectj-autoproxy，scoped-proxy，spring-configured 注册到BeanDefinitionParsers

六、其他

  • 1、MethodLocatingFactoryBean

    在指定bean上定位方法的FactoryBean实现

  • 2、SimpleBeanFactoryAwareAspectInstanceFactory

    AspectInstanceFactory的实现，它使用配置的bean名称从BeanFactory定位切面

转载自:https://juejin.cn/post/7371384453358747663
评论
请登录