• Spring原理学习（八）AOP底层实现

    一、Advice、Advisor、Advised接口

    Advice: org.aopalliance.aop.Advice
    “通知”，实际增强的逻辑部分。

    Pointcut: org.springframework.aop.Pointcut
    “切点”，一些特使的连接点，是具体附加通知的地方。例如坐地铁的时候，具体在某个站下车，那这个站就是切入点。

    • 连接点：在应用执行过程中能够插入切面（Aspect）的一个点。例如坐地铁的时候，每一个站都可以下车，那么这每一个站都是一个接入点。假如一个对象中有多个方法，那么这个每一个方法就是一个连接点。

    Advisor: org.springframework.aop.Advisor
    “通知者”，它持有 Advice，是 Spring AOP 的一个基础接口。

    Advised: org.springframework.aop.framework.Advised
    AOP 代理工厂配置类接口。提供了操作和管理 Advice 和 Advisor 的能力。

    1、Advice、Advisor、Advised 类图

    1. Advisor 可以获取到 Advice。

    2. PointcutAdvisor 可以获取到 Pointcut 和 Advice。
    Pointcut 可以匹配连接点，Advice 是具体的通知，所以，PointcutAdvisor 是一个功能完善接口。

    3. Advised 是 AOP 代理工厂配置类接口，它可以操作和管理 Advice 和 Advisor，它的实现类有 ProxyFactory、AspectJProxyFactory，用于生成AOP 代理类。

    2、Advice

     Advice 大体上分为了三类：BeforeAdvice、MethodInterceptor、AfterAdvice

    可以看出，MethodInterceptor 是功能最强大的，它能够处理 BeforeAdvice、AroundAdvice、AfterAdvice、ThrowsAdvice、@Valid方法参数校验、@Async异步等

    3、Advisor

    Advisor 大体分为了三类：PointcutAdvisor、IntroductionAdvisor、PrototypePlaceholderAdvisor
    其中，用到的最多的就是 PointcutAdvisor，它涵盖了绝大部分的 Advisor。 

    PointcutAdvisor

    PointcutAdvisor 是一个功能完善接口，也是 Spring AOP 中使用最多的，它涵盖了绝大部分的 Advisor。

    通过 PointcutAdvisor 可以获取到 Pointcut 和 Advice。Pointcut 可以完成连接点的匹配，而 Advice 就是在连接点上具体要执行的"通知"。

    4、Advised

     

    Advised 是 AOP 代理工厂配置类接口。

    它的实现类有：ProxyFactory、AspectJProxyFactory、ProxyFactoryBean。
    Advised 提供了操作和管理 Advice 和 Advisor 的能力，所以，ProxyFactory 实现 Advised 之后，就可以方便的获取和操作 Advice、Advisor，从而创建 AOP 代理类了。

    Advised、ProxyConfig、AdvisedSupport 都是跟 Spring AOP 代理配置相关的接口和类，它们可以统一 Spring AOP 的代理配置。

    参考文章：【Spring源码三千问】Advice、Advisor、Advised都是什么接口？

    二、Spring的代理选择规则

    代理相关类图

    • AopProxyFactory 根据 proxyTargetClass 等设置选择 AopProxy 实现

    • AopProxy 通过 getProxy 创建代理对象

    • 图中 Proxy 都实现了 Advised 接口，能够获得关联的切面集合与目标（其实是从 ProxyFactory 取得）

    • 调用代理方法时，会借助 ProxyFactory 将通知统一转为环绕通知：MethodInterceptor

    先说结论： 

    • proxyTargetClass = false, 目标实现了接口, 用 jdk 实现
    • proxyTargetClass = false, 目标没有实现接口, 用 cglib 实现
    • proxyTargetClass = true, 总是使用 cglib 实现
    1. public class A15 {
    2.     public static void main(String[] args) {
    3.  
    4.         // 1. 备好切点
    5.         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    6.         pointcut.setExpression("execution(* foo())");
    7.  
    8.         // 2. 备好通知 ,注意同名MethodInterceptor
    9.         MethodInterceptor advice = new MethodInterceptor() {
    10.             @Override
    11.             public Object invoke(MethodInvocation invocation) throws Throwable {
    12.                 System.out.println("before...");
    13.                 //调用目标
    14.                 Object result = invocation.proceed();
    15.                 System.out.println("after...");
    16.                 return result;
    17.             }
    18.         };
    19.  
    20.         // 3. 备好切面
    21.         DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    22.           
    23.         //4. 创建代理   
    24.         Target1 target1 = new Target1();
    25.         ProxyFactory factory = new ProxyFactory();
    26.         factory.setTarget(target1);
    27.         factory.addAdvisor(advisor);
    28.  
    29.         I1 proxy = (I1) factory.getProxy();
    30.         
    31.         //5. 调用增强后的方法
    32.         System.out.println(proxy.getClass());
    33.         proxy.foo();
    34.         proxy.bar();
    35.     }
    36.  
    37.     interface I1 {
    38.         void foo();
    39.  
    40.         void bar();
    41.     }
    42.  
    43.     static class Target1 implements I1 {
    44.         public void foo() {
    45.             System.out.println("target1 foo");
    46.         }
    47.  
    48.         public void bar() {
    49.             System.out.println("target1 bar");
    50.         }
    51.     }
    52.  
    53.     static class Target2 {
    54.         public void foo() {
    55.             System.out.println("target2 foo");
    56.         }
    57.  
    58.         public void bar() {
    59.             System.out.println("target2 bar");
    60.         }
    61.     }
    62. }

     结果：使用 CGLIB 实现，不应该是 JDK 吗？

    1. class com.itheima.a15.A15$Target1$$EnhancerBySpringCGLIB$$88a7fb77
    2. before...
    3. target1 foo
    4. after...
    5. target1 bar

    解释：因为生成代理类时并不知道目标类是否实现了接口，需要告诉工厂目标类实现的接口

    factory.setInterfaces(target1.getClass().getInterfaces());

    设置接口后再进行测试，使用JDK实现

    class com.itheima.a15.$Proxy2

    设置 ProxyTargetClass 为 true 再进行测试，使用CGLIB实现

    factory.setProxyTargetClass(true);
    class com.itheima.a15.A15$Target1$$EnhancerBySpringCGLIB$$abb40a5f

    总结

    ProxyFactory 是用来创建代理的核心实现，用 AopProxyFactory 选择具体代理实现

    • JdkDynamicAopProxy
    • ObjenesisCglibAopProxy

    注意：要区分上面提到的 MethodInterceptor，它与之前 CGLIB 中用的的 MethodInterceptor 是不同的接口

    三、切点匹配

    1、根据指定的方法进行匹配

    1. public class A16 {
    2.     public static void main(String[] args) throws NoSuchMethodException {
    3.         AspectJExpressionPointcut pt1 = new AspectJExpressionPointcut();
    4.         //根据指定的方法进行匹配
    5.         pt1.setExpression("execution(* bar())");
    6.         //判断是否匹配
    7.         System.out.println(pt1.matches(T1.class.getMethod("foo"), T1.class));
    8.         System.out.println(pt1.matches(T1.class.getMethod("bar"), T1.class));
    9.     }
    10.  
    11.     static class T1 {
    12.         public void foo() {
    13.         }
    14.         public void bar() {
    15.         }
    16.     }
    17. }

    matches方法的第二个参数可以随意指定，对于结果没有影响，后面在自己实现切点匹配时会解释。 

    结果：

    1. false
    2. true

    2、根据方法上的注解进行匹配

    1. public class A16 {
    2.     public static void main(String[] args) throws NoSuchMethodException {
    3.         AspectJExpressionPointcut pt2 = new AspectJExpressionPointcut();
    4.         //根据方法上的注解进行匹配
    5.         pt2.setExpression("@annotation(org.springframework.transaction.annotation.Transactional)");
    6.         System.out.println(pt2.matches(T1.class.getMethod("foo"), T1.class));
    7.         System.out.println(pt2.matches(T1.class.getMethod("bar"), T1.class));
    8.     }
    9.  
    10.     static class T1 {
    11.         @Transactional
    12.         public void foo() {
    13.         }
    14.         public void bar() {
    15.         }
    16.     }
    17. }

    结果：

    1. true
    2. false

    3、自己实现切点匹配

    MergedAnnotations是一个注解的工具类

    1. public class A16 {
    2.     public static void main(String[] args) throws NoSuchMethodException {
    3.         StaticMethodMatcherPointcut pt3 = new StaticMethodMatcherPointcut() {
    4.             @Override
    5.             public boolean matches(Method method, Class targetClass) {
    6.                 /* 检查方法上是否加了 Transactional 注解 */
    7.  
    8.                 //获取方法上标注的注解
    9.                 MergedAnnotations annotations = MergedAnnotations.from(method);
    10.                 //是否有@Transactional注解
    11.                 if (annotations.isPresent(Transactional.class)) {
    12.                     return true;
    13.                 }
    14.  
    15.                 /* 查看类上是否加了 Transactional 注解 */
    16.  
    17.                 //获取类上标注的注解
    18.                 annotations = MergedAnnotations.from(targetClass, MergedAnnotations.SearchStrategy.TYPE_HIERARCHY);
    19.                 //是否有@Transactional注解
    20.                 if (annotations.isPresent(Transactional.class)) {
    21.                     return true;
    22.                 }
    23.                 return false;
    24.             }
    25.         };
    26.  
    27.         System.out.println(pt3.matches(T1.class.getMethod("foo"), T1.class));
    28.         System.out.println(pt3.matches(T1.class.getMethod("bar"), T1.class));
    29.         System.out.println(pt3.matches(T2.class.getMethod("foo"), T2.class));
    30.         System.out.println(pt3.matches(T3.class.getMethod("foo"), T3.class));
    31.     }
    32.  
    33.  
    34.     static class T1 {
    35.         @Transactional
    36.         public void foo() {
    37.         }
    38.         public void bar() {
    39.         }
    40.     }
    41.  
    42.     @Transactional
    43.     static class T2 {
    44.         public void foo() {
    45.         }
    46.     }
    47.  
    48.     @Transactional
    49.     interface I3 {
    50.         void foo();
    51.     }
    52.     static class T3 implements I3 {
    53.         public void foo() {
    54.         }
    55.     }
    56. }

     说明：from方法默认的搜索策略是在本类，那么如果在接口或者父类上标注 @Transactional 注解则查找不到。

    1.     static MergedAnnotations from(AnnotatedElement element) {
    2.         return from(element, MergedAnnotations.SearchStrategy.DIRECT);
    3.     }

    所以更换了策略 

    MergedAnnotations.SearchStrategy.TYPE_HIERARCHY：从继承树查找

    默认策略的结果：

    1. true
    2. false
    3. true
    4. false

    指定为 TYPE_HIERARCHY 策略的结果：

    1. true
    2. false
    3. true
    4. true

    总结

    • 底层切点实现是如何匹配的：调用了 aspectj 的匹配方法，比较关键的是它实现了 MethodMatcher 接口，用来执行方法的匹配。
    • aspectj 切点的局限性：只能匹配方法的信息

    四、从 @Aspect 到 Advisor

    两个切面概念

    aspect =

    • 通知1(advice) + 切点1(pointcut)
    • 通知2(advice) + 切点2(pointcut)
    • 通知3(advice) + 切点3(pointcut)
    • ...

    advisor =

    • 更细粒度的切面，包含一个通知和切点

    aspect：高级切面，advisor：低级切面

    1、代理创建器

    AnnotationAwareAspectJAutoProxyCreator其实是个Bean后处理器，具体可以看它的继承关系。

    AnnotationAwareAspectJAutoProxyCreator的作用：

    • 将高级 @Aspect 切面统一为低级 Advisor 切面

    • 在合适的时机创建代理

    1. public class A17 {
    2.     public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    3.         GenericApplicationContext context = new GenericApplicationContext();
    4.         context.registerBean("aspect1", Aspect1.class);
    5.         context.registerBean("config", Config.class);
    6.         context.registerBean(ConfigurationClassPostProcessor.class);
    7.  
    8.         //解析@Aspect，产生代理
    9.         context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);
    10.  
    11.         context.refresh();
    12.  
    13.         /*
    14.         第一个重要方法 findEligibleAdvisors：找到有资格的Advisors
    15.             a. 有资格的 Advisor 一部分是低级的，可以由自己编写，如下例中的 advisor3
    16.             b. 有资格的 Advisor 一部分是高级的，由解析 @Aspect 后获得
    17.          */
    18.         AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
    19.         Method findEligibleAdvisors = creator.getClass().getSuperclass().getSuperclass().
    20.                 getDeclaredMethod("findEligibleAdvisors", Class.class, String.class);
    21.         findEligibleAdvisors.setAccessible(true);
    22.         //找到和 Target1 类匹配的所有切面
    23.         // 参数一：目标类型，参数二：bean名字，由于没交给spring管理，随便写一个
    24.         List advisors = (List) findEligibleAdvisors.invoke(creator, Target1.class, "target1");
    25.         for (Advisor advisor : advisors) {
    26.             System.out.println(advisor);
    27.         }
    28.  
    29.         System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>");
    30.  
    31.  
    32.         /*
    33.         第二个重要方法 wrapIfNecessary
    34.             a. 它内部调用 findEligibleAdvisors，只要返回集合不为空，则表示需要创建代理
    35.          */
    36.  
    37.         //参数一：目标对象 参数二：bean名字，由于没交给spring管理，随便写一个 参数三：对于这个操作没用，随便写一个
    38.         Method wrapIfNecessary = creator.getClass().getSuperclass().getSuperclass().getSuperclass().
    39.                 getDeclaredMethod("wrapIfNecessary", Object.class, String.class, Object.class);
    40.         wrapIfNecessary.setAccessible(true);
    41.         Object o1 = wrapIfNecessary.invoke(creator, new Target1(), "target1", "target1");
    42.         //代理对象
    43.         System.out.println(o1.getClass());
    44.         Object o2 = wrapIfNecessary.invoke(creator, new Target2(), "target2", "target2");
    45.         //对象本身
    46.         System.out.println(o2.getClass());
    47.  
    48.         ((Target1) o1).foo();
    49.  
    50.     }
    51.     static class Target1 {
    52.         public void foo(){
    53.             System.out.println("target1 foo");
    54.         }
    55.     }
    56.  
    57.     static class Target2 {
    58.         public void bar(){
    59.             System.out.println("target2 bar");
    60.         }
    61.     }
    62.  
    63.     @Aspect //高级切面类
    64.     static class Aspect1 {
    65.         @Before("execution(* foo())")
    66.         public void before(){
    67.             System.out.println("aspect1 before...");
    68.         }
    69.  
    70.         @After("execution(* foo())")
    71.         public void after(){
    72.             System.out.println("aspect1 after...");
    73.         }
    74.     }
    75.  
    76.     @Configuration
    77.     static class Config {
    78.         @Bean//低级切面
    79.         public Advisor advisor3(MethodInterceptor advice3){
    80.             AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    81.             pointcut.setExpression("execution(* foo())");
    82.             DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice3);
    83.             return advisor;
    84.         }
    85.  
    86.         @Bean
    87.         public MethodInterceptor advice3() {
    88.             return new MethodInterceptor() {
    89.                 @Override
    90.                 public Object invoke(MethodInvocation invocation) throws Throwable {
    91.                     System.out.println("advice3 before...");
    92.                     Object result = invocation.proceed();
    93.                     System.out.println("advice3 after...");
    94.                     return result;
    95.                 }
    96.             };
    97.         }
    98.     }
    99. }

    结果：

    1. //spring加的,暴露调用器的拦截器,作用后面会讲
    2. org.springframework.aop.interceptor.ExposeInvocationInterceptor.ADVISOR
    3.  
    4. //低级切面
    5. org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [com.itheima.a17.A17$Config$1@209da20d]
    6.  
    7. //高级切面转换后的低级切面
    8. InstantiationModelAwarePointcutAdvisor: expression [execution(* foo())]; advice method [public void com.itheima.a17.A17$Aspect1.before()]; perClauseKind=SINGLETON
    9. InstantiationModelAwarePointcutAdvisor: expression [execution(* foo())]; advice method [public void com.itheima.a17.A17$Aspect1.after()]; perClauseKind=SINGLETON
    10.  
    11. >>>>>>>>>>>>>>>>>>>>>>>>>>
    12. [TRACE] 16:10:29.788 [main] o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator - Creating implicit proxy for bean 'target1' with 0 common interceptors and 4 specific interceptors 
    13. class com.itheima.a17.A17$Target1$$EnhancerBySpringCGLIB$$a2f64ee5
    14. class com.itheima.a17.A17$Target2
    15.  
    16. advice3 before...
    17. aspect1 before...
    18. target1 foo
    19. aspect1 after...
    20. advice3 after...

    总结

    1. AnnotationAwareAspectJAutoProxyCreator 的作用

      • 将高级 @Aspect 切面统一为低级 Advisor 切面

      • 在合适的时机创建代理

    2. findEligibleAdvisors 找到有【资格】的 Advisors

      • 有【资格】的 Advisor 一部分是低级的, 可以由自己编写, 如本例 A17 中的 advisor3

      • 有【资格】的 Advisor 另一部分是高级的, 由解析 @Aspect 后获得

    3. wrapIfNecessary

      • 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理

      • 它的调用时机通常在原始对象初始化后执行, 但碰到循环依赖会提前至依赖注入之前执行

    2、代理创建时机

    1）代理的创建时机：

    • 初始化之后 (无循环依赖时)

    • 实例创建后，依赖注入前 (有循环依赖时)，并暂存于二级缓存

    注意：不会重复创建代理，两个位置二选一

    无循环依赖

    1. public class A17_1 {
    2.     public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    3.         GenericApplicationContext context = new GenericApplicationContext();
    4.         context.registerBean(Config.class);
    5.         context.registerBean(ConfigurationClassPostProcessor.class);
    6.  
    7.         context.refresh();
    8.     }
    9.  
    10.     @Configuration
    11.     static class Config {
    12.         @Bean //解析 @Aspect，产生代理
    13.         public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator() {
    14.             return new AnnotationAwareAspectJAutoProxyCreator();
    15.         }
    16.  
    17.         @Bean //解析 @Autowired
    18.         public AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor() {
    19.             return new AutowiredAnnotationBeanPostProcessor();
    20.         }
    21.  
    22.         @Bean //解析 @PostConstruct
    23.         public CommonAnnotationBeanPostProcessor commonAnnotationBeanPostProcessor() {
    24.             return new CommonAnnotationBeanPostProcessor();
    25.         }
    26.  
    27.         @Bean
    28.         public Advisor advisor(MethodInterceptor advice) {
    29.             AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    30.             pointcut.setExpression("execution(* foo())");
    31.             return new DefaultPointcutAdvisor(pointcut, advice);
    32.         }
    33.  
    34.         @Bean
    35.         public MethodInterceptor advice(){
    36.             return new MethodInterceptor() {
    37.                 @Override
    38.                 public Object invoke(MethodInvocation invocation) throws Throwable {
    39.                     System.out.println("before...");
    40.                     Object result = invocation.proceed();
    41.                     return result;
    42.                 }
    43.             };
    44.         }
    45.  
    46.         @Bean
    47.         public Bean1 bean1() {
    48.             return new Bean1();
    49.         }
    50.  
    51.         @Bean
    52.         public Bean2 bean2() {
    53.             return new Bean2();
    54.         }
    55.     }
    56.  
    57.     static class Bean1 {
    58.  
    59.         public void foo(){
    60.  
    61.         }
    62.  
    63.         public Bean1(){
    64.             System.out.println("Bean1()");
    65.         }
    66.  
    67.         @PostConstruct
    68.         public void init() {
    69.             System.out.println("Bean1 init()");
    70.         }
    71.     }
    72.  
    73.     static class Bean2 {
    74.  
    75.         public Bean2(){
    76.             System.out.println("Bean2()");
    77.         }
    78.  
    79.         @Autowired
    80.         public void setBean1(Bean1 bean1) {
    81.             System.out.println("Bean2 setBean1(bean1) class is: " + bean1.getClass());
    82.         }
    83.  
    84.         @PostConstruct
    85.         public void init() {
    86.             System.out.println("Bean2 init()");
    87.         }
    88.     }
    89. }

    结果：

    1. Bean1()
    2. Bean1 init()
    3. [TRACE] 16:21:47.952 [main] o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator - Creating implicit proxy for bean 'bean1' with 0 common interceptors and 2 specific interceptors 
    4. Bean2()
    5. Bean2 setBean1(bean1) class is: class com.itheima.a17.A17_1$Bean1$$EnhancerBySpringCGLIB$$b0011e5d
    6. Bean2 init()

    有循环依赖时

    1.     static class Bean1 {
    2.  
    3.         public void foo(){
    4.  
    5.         }
    6.  
    7.         public Bean1(){
    8.             System.out.println("Bean1()");
    9.         }
    10.  
    11.         @Autowired
    12.         public void setBean1(Bean2 bean2) {
    13.             System.out.println("Bean1 setBean2(bean2) class is: " + bean2.getClass());
    14.         }
    15.  
    16.         @PostConstruct
    17.         public void init() {
    18.             System.out.println("Bean1 init()");
    19.         }
    20.     }
    21.  
    22.     static class Bean2 {
    23.  
    24.         public Bean2(){
    25.             System.out.println("Bean2()");
    26.         }
    27.  
    28.         @Autowired
    29.         public void setBean1(Bean1 bean1) {
    30.             System.out.println("Bean2 setBean1(bean1) class is: " + bean1.getClass());
    31.         }
    32.  
    33.         @PostConstruct
    34.         public void init() {
    35.             System.out.println("Bean2 init()");
    36.         }
    37.     }

    结果：

    1. Bean1()
    2. Bean2()
    3. [TRACE] 16:23:35.276 [main] o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator - Creating implicit proxy for bean 'bean1' with 0 common interceptors and 2 specific interceptors 
    4. Bean2 setBean1(bean1) class is: class com.itheima.a17.A17_1$Bean1$$EnhancerBySpringCGLIB$$2d7cace9
    5. Bean2 init()
    6. Bean1 setBean2(bean2) class is: class com.itheima.a17.A17_1$Bean2
    7. Bean1 init()

    3、@Before 对应的低级通知

    @Before 前置通知会被转换为原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息

    1. 通知代码从哪儿来

    2. 切点是什么(这里为啥要切点, 后面解释)

    3.  Aspect 对象，将来反射调用切面类的方法需要切面类对象

    类似的还有：

    1. AspectJAroundAdvice (环绕通知)

    2. AspectJAfterReturningAdvice

    3. AspectJAfterThrowingAdvice (环绕通知)

    4. AspectJAfterAdvice (环绕通知)

    环绕通知：实现了 MethodInterceptor 接口的类

    1. public class A17_2 {
    2.     static class Aspect {
    3.         @Before("execution(* foo())")
    4.         public void before1() {
    5.             System.out.println("before1");
    6.         }
    7.  
    8.         @Before("execution(* foo())")
    9.         public void before2() {
    10.             System.out.println("before2");
    11.         }
    12.  
    13.         public void after() {
    14.             System.out.println("after");
    15.         }
    16.     }
    17.  
    18.     static class Target {
    19.         public void foo() {
    20.             System.out.println("target foo");
    21.         }
    22.     }
    23.  
    24.     public static void main(String[] args) {
    25.         //切面对象工厂，将来由工厂拿到切面对象
    26.         AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());
    27.         List list = new ArrayList<>();
    28.         //高级切面转低级切面类
    29.         for (Method method : Aspect.class.getDeclaredMethods()) {
    30.             //方法上是否标注 @Before 注解
    31.             if (method.isAnnotationPresent(Before.class)) {
    32.                 //解析切点
    33.                 String expression = method.getAnnotation(Before.class).value();
    34.                 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    35.                 pointcut.setExpression(expression);
    36.  
    37.                 //通知类
    38.                 //参数三：将来反射调用切面类的方法需要切面类对象，所以需要传入切面类对象，具体从工厂获取
    39.                 AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);
    40.  
    41.                 //切面
    42.                 DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    43.  
    44.                 list.add(advisor);
    45.             }
    46.         }
    47.         for (Advisor advisor : list) {
    48.             System.out.println(advisor);
    49.         }
    50.     }
    51. }

    结果：

    1. org.springframework.aop.support.DefaultPointcutAdvisor: 
    2. pointcut [AspectJExpressionPointcut: () execution(* foo())]; 
    3. advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void com.itheima.a17.A17_2$Aspect.before1()]; aspect name '']
    4.  
    5. org.springframework.aop.support.DefaultPointcutAdvisor: 
    6. pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: 
    7. advice method [public void com.itheima.a17.A17_2$Aspect.before2()]; aspect name '']

    五、静态通知调用

    步骤：

    1. 高级切面转低级切面类
    2. 通知统一转换为环绕通知 MethodInterceptor
    3. 创建并执行调用链 (所有的环绕通知 + 目标)

    1、通知为什么需要统一转换为环绕通知？

    其实无论proxyFactory基于哪种方式创建，最后干活(调用 advice)的是一个 MethodInvocation 对象

    1）因为 advisor 有多个，且一个套一个调用，因此需要一个调用链对象，即 MethodInvocation

    2）MethodInvocation 要知道 advice 有哪些，还要知道目标，调用次序

    3）从上图可以看出，环绕通知才适合作为 advice，因此其他 before，afterReturning 都会被转换为环绕通知

    如何统一转换为 MethodInterceptor 环绕通知？

    统一转换为环绕通知，体现的是设计模式的适配器模式

    • 对外是为了方便使用要区分 before, afterReturning, afterThrowing
    • 对内统一都是环绕通知，统一用 MethodInterceptor 表示

    适配如下

    • MethodBeforeAdviceAdapter 将 AspectJMethodBeforeAdvice 适配为 MethodBeforeAdviceInterceptor
    • AfterReturningAdviceAdapter 将 AspectJAfterReturningAdvice 适配为 MethodAfterReturningAdviceInterceptor
    1. class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
    2.     MethodBeforeAdviceAdapter() {
    3.     }
    4.  
    5.     //支持哪种通知的适配
    6.     public boolean supportsAdvice(Advice advice) {
    7.         return advice instanceof MethodBeforeAdvice;
    8.     }
    9.  
    10.     //转换成 MethodInterceptor 接口
    11.     public MethodInterceptor getInterceptor(Advisor advisor) {
    12.         MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
    13.         return new MethodBeforeAdviceInterceptor(advice);
    14.     }
    15. }

    2、模拟静态通知调用

    1. public class A18 {
    2.     static class Aspect {
    3.         @Before("execution(* foo())")
    4.         public void before1() {
    5.             System.out.println("before1");
    6.         }
    7.  
    8.         @Before("execution(* foo())")
    9.         public void before2() {
    10.             System.out.println("before2");
    11.         }
    12.  
    13.         public void after() {
    14.             System.out.println("after");
    15.         }
    16.  
    17.         @AfterReturning("execution(* foo())")
    18.         public void afterReturning() {
    19.             System.out.println("afterReturning");
    20.         }
    21.  
    22.         @AfterThrowing("execution(* foo())")
    23.         public void afterThrowing(Exception e) {
    24.             System.out.println("afterThrowing" + e.getMessage());
    25.         }
    26.  
    27.         @Around("execution(* foo())")
    28.         public Object around(ProceedingJoinPoint pjp) throws Throwable{
    29.             System.out.println("around before...");
    30.             Object result = pjp.proceed();
    31.             System.out.println("around after...");
    32.             return result;
    33.         }
    34.     }
    35.  
    36.     static class Target {
    37.         public void foo() {
    38.             System.out.println("target foo");
    39.         }
    40.     }
    41.  
    42.     public static void main(String[] args) throws Throwable {
    43.  
    44.         /* 1. 高级切面转低级切面类 */
    45.  
    46.         //切面对象工厂，由工厂拿到切面对象
    47.         AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());
    48.         List list = new ArrayList<>();
    49.         for (Method method : Aspect.class.getDeclaredMethods()) {
    50.             //方法上是否标注 @Before 注解
    51.             if (method.isAnnotationPresent(Before.class)) {
    52.                 //解析切点
    53.                 String expression = method.getAnnotation(Before.class).value();
    54.                 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    55.                 pointcut.setExpression(expression);
    56.  
    57.                 //通知类
    58.                 AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);
    59.  
    60.                 //切面
    61.                 DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    62.  
    63.                 list.add(advisor);
    64.             } else if (method.isAnnotationPresent(AfterReturning.class)) {
    65.                 //方法上是否标注 @AfterReturning 注解
    66.                 if (method.isAnnotationPresent(AfterReturning.class)) {
    67.                     //解析切点
    68.                     String expression = method.getAnnotation(AfterReturning.class).value();
    69.                     AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    70.                     pointcut.setExpression(expression);
    71.  
    72.                     //通知类
    73.                     AspectJAfterReturningAdvice advice = new AspectJAfterReturningAdvice(method, pointcut, factory);
    74.  
    75.                     //切面
    76.                     DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    77.  
    78.                     list.add(advisor);
    79.                 }
    80.             } else if (method.isAnnotationPresent(Around.class)) {
    81.                 //方法上是否标注 @Around 注解
    82.                 if (method.isAnnotationPresent(Around.class)) {
    83.                     //解析切点
    84.                     String expression = method.getAnnotation(Around.class).value();
    85.                     AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    86.                     pointcut.setExpression(expression);
    87.  
    88.                     //通知类
    89.                     AspectJAroundAdvice advice = new AspectJAroundAdvice(method, pointcut, factory);
    90.  
    91.                     //切面
    92.                     DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    93.  
    94.                     list.add(advisor);
    95.                 }
    96.             }
    97.         }
    98.  
    99.         for (Advisor advisor : list) {
    100.             System.out.println(advisor);
    101.         }
    102.  
    103.         System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    104.  
    105.         /* 省略了 advisor 排序步骤 */
    106.  
    107.         /* 2. 通知统一转换为环绕通知 MethodInterceptor */
    108.  
    109.         ProxyFactory proxyFactory = new ProxyFactory();
    110.         Target target = new Target();
    111.         proxyFactory.setTarget(target);
    112.         //准备把 MethodInvocation 放入当前通知
    113.         proxyFactory.addAdvice(ExposeInvocationInterceptor.INSTANCE); 
    114.         proxyFactory.addAdvisors(list);
    115.  
    116.         //把除了环绕通知以外的其他类型通知统一转换为环绕通知
    117.         List methodInterceptorList =
    118.                 proxyFactory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo"), Target.class);
    119.         for (Object o : methodInterceptorList) {
    120.             System.out.println(o);
    121.         }
    122.  
    123.         /* 3. 创建并执行调用链 (所有的环绕通知 + 目标) */
    124.         Constructor constructor = ReflectiveMethodInvocation.class.getDeclaredConstructor(
    125.                 Object.class, Object.class, Method.class, Object[].class, Class.class, List.class);
    126.         constructor.setAccessible(true);
    127.         ReflectiveMethodInvocation methodInvocation = constructor.newInstance(
    128.                 null, target, Target.class.getMethod("foo"), new Object[0], Target.class, methodInterceptorList);
    129.         methodInvocation.proceed();
    130.     /*
    131.         此步模拟调用链过程，是一个简单的递归调用
    132.             1. proceed() 方法调用链中下一个环绕通知
    133.             2. 每个环绕通知内部继续调用 proceed()
    134.             3. 调用到没有更多通知了，就调用目标方法
    135.      */
    136.     }
    137. }
      138.  

      结果：
       

      1. org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJAroundAdvice: advice method [public java.lang.Object com.itheima.a18.A18$Aspect.around(org.aspectj.lang.ProceedingJoinPoint) throws java.lang.Throwable]; aspect name '']
      2. org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJAfterReturningAdvice: advice method [public void com.itheima.a18.A18$Aspect.afterReturning()]; aspect name '']
      3. org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void com.itheima.a18.A18$Aspect.before1()]; aspect name '']
      4. org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void com.itheima.a18.A18$Aspect.before2()]; aspect name '']
      5. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      6. org.springframework.aop.interceptor.ExposeInvocationInterceptor@8e24743
      7. org.springframework.aop.aspectj.AspectJAroundAdvice: advice method [public java.lang.Object com.itheima.a18.A18$Aspect.around(org.aspectj.lang.ProceedingJoinPoint) throws java.lang.Throwable]; aspect name ''
      8. org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor@74a10858
      9. org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@23fe1d71
      10. org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@28ac3dc3
      11. around before...
      12. before1
      13. before2
      14. target foo
      15. afterReturning
      16. around after...
       

      ExposeInvocationInterceptor的作用
       

      某些通知会用到 MethodInvocation，在执行的时候，需要放在公共的位置，让所有的通知都能找到，如果某个通知想取的时候没取到，就会报如下错误：
       

       

      如何放置？
       

      ExposeInvocationInterceptor的作用就是将 MethodInvocation 放到当前线程，这样所有通知就都能获取到了，它同时也是个环绕通知，那把它放到最外层的环绕通知就可以了。
       

      总结 
       

      代理方法执行时会做如下工作
       

      1. 通过 proxyFactory 的 getInterceptorsAndDynamicInterceptionAdvice() 将其他通知统一转换为 MethodInterceptor 环绕通知。这体现的是适配器设计模式
       

      2. 所谓静态通知，体现在上面方法的 Interceptors 部分，这些通知调用时无需再次检查切点，直接调用即可
       

      3. 结合目标与环绕通知链，创建 MethodInvocation 对象，通过它完成整个调用
       

      3、模拟 MethodInvocation
       

      用到的是职责链模式
       

      1. public class A18_1 {
      2.  
      3.     static class Target {
      4.         public void foo() {
      5.             System.out.println("Target.foo()");
      6.         }
      7.     }
      8.  
      9.     static class Advice1 implements MethodInterceptor {
      10.         @Override
      11.         public Object invoke(MethodInvocation invocation) throws Throwable {
      12.             System.out.println("Advice1.before()");
      13.             Object result = invocation.proceed(); //调用下一个通知目标
      14.             System.out.println("Advice1.after()");
      15.             return result;
      16.         }
      17.     }
      18.  
      19.     static class Advice2 implements MethodInterceptor {
      20.         @Override
      21.         public Object invoke(MethodInvocation invocation) throws Throwable {
      22.             System.out.println("Advice2.before()");
      23.             Object result = invocation.proceed(); //调用下一个通知目标
      24.             System.out.println("Advice2.after()");
      25.             return result;
      26.         }
      27.     }
      28.  
      29.     static class MyInvocation implements MethodInvocation {
      30.  
      31.         private Object targrt;
      32.         private Method method;
      33.         private Object[] args;
      34.         private List methodInterceptorList;
      35.         private int count = 1; //调用次数
      36.  
      37.         public MyInvocation(Object targrt, Method method, Object[] args, List methodInterceptorList) {
      38.             this.targrt = targrt;
      39.             this.method = method;
      40.             this.args = args;
      41.             this.methodInterceptorList = methodInterceptorList;
      42.         }
      43.  
      44.         @Override
      45.         public Method getMethod() {
      46.             return method;
      47.         }
      48.  
      49.         @Override
      50.         public Object[] getArguments() {
      51.             return args;
      52.         }
      53.  
      54.         @Override
      55.         public Object proceed() throws Throwable { //调用每一个环绕通知，调用目标
      56.             if (count > methodInterceptorList.size()) {
      57.                 //调用目标，返回并结束通知
      58.                 return method.invoke(targrt, args);
      59.             }
      60.             //逐一调用通知
      61.             MethodInterceptor methodInterceptor = methodInterceptorList.get(count++ - 1);
      62.             return methodInterceptor.invoke(this);
      63.         }
      64.  
      65.         @Override
      66.         public Object getThis() {
      67.             return targrt;
      68.         }
      69.  
      70.         @Override
      71.         public AccessibleObject getStaticPart() {
      72.             return method;
      73.         }
      74.     }
      75.  
      76.     public static void main(String[] args) throws Throwable {
      77.         Target target = new Target();
      78.         ArrayList list = new ArrayList<>();
      79.         list.add(new Advice1());
      80.         list.add(new Advice2());
      81.         MyInvocation myInvocation = new MyInvocation(target, Target.class.getMethod("foo"), new Object[0], list);
      82.         myInvocation.proceed();
      83.     }
      84. }
       

      结果：
       

      1. Advice1.before()
      2. Advice2.before()
      3. Target.foo()
      4. Advice2.after()
      5. Advice1.after()
       

       具体过程：
       

      1.  
        proceed() 方法调用链中下一个环绕通知
         
      2.  
        每个环绕通知内部继续调用 proceed()
         
      3.  
        调用到没有更多通知了, 就调用目标方法
         
       

      MethodInvocation 的编程技巧在实现拦截器、过滤器时能用上
       

      六、动态通知调用
       

      带参数绑定的通知方法调用
       

      1. public class A19 {
      2.     @Aspect
      3.     static class MyAspect {
      4.         @Before("execution(* foo(..))") //静态通知调用，不需要参数绑定，执行时不需要切点
      5.         public void before1(){
      6.             System.out.println("before1");
      7.         }
      8.  
      9.         @Before("execution(* foo(..)) && args(x)") //动态通知调用，需要参数绑定，执行时需要切点对象
      10.         public void before2(int x){
      11.             System.out.printf("before2(%d)%n", x);
      12.         }
      13.     }
      14.  
      15.     static class Target {
      16.         public void foo(int x) {
      17.             System.out.printf("target foo(%d)%n", x);
      18.         }
      19.     }
      20.  
      21.     @Configuration
      22.     static class MyConfig {
      23.         @Bean
      24.         AnnotationAwareAspectJAutoProxyCreator proxyCreator() {
      25.             return new AnnotationAwareAspectJAutoProxyCreator();
      26.         }
      27.  
      28.         @Bean
      29.         public MyAspect myAspect() {
      30.             return new MyAspect();
      31.         }
      32.     }
      33.  
      34.     public static void main(String[] args) throws Throwable {
      35.         GenericApplicationContext context = new GenericApplicationContext();
      36.         context.registerBean(ConfigurationClassPostProcessor.class);
      37.         context.registerBean(MyConfig.class);
      38.         context.refresh();
      39.         
      40.         AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
      41.         Method findEligibleAdvisors = creator.getClass().getSuperclass().getSuperclass().
      42.                 getDeclaredMethod("findEligibleAdvisors", Class.class, String.class);
      43.         findEligibleAdvisors.setAccessible(true);
      44.         //找到和Target匹配的切面
      45.         List list = (List) findEligibleAdvisors.invoke(creator, Target.class, "target");
      46.  
      47.         Target target = new Target();
      48.         ProxyFactory factory = new ProxyFactory();
      49.         factory.setTarget(target);
      50.         factory.addAdvisors(list);
      51.         //获取代理
      52.         Object proxy = factory.getProxy();
      53.  
      54.         //把除了环绕通知以外的其他类型通知统一转换为环绕通知
      55.         List interceptorList =
      56.                 factory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo", int.class), Target.class);
      57.  
      58.         for (Object o : interceptorList) {
      59.             showDetail(o);
      60.         }
      61.  
      62.         //创建并执行调用链
      63.         Constructor constructor = ReflectiveMethodInvocation.class.getDeclaredConstructor(
      64.                 Object.class, Object.class, Method.class, Object[].class, Class.class, List.class);
      65.         constructor.setAccessible(true);
      66.         ReflectiveMethodInvocation methodInvocation = constructor.newInstance(
      67.                 proxy, target, Target.class.getMethod("foo", int.class), new Object[]{100}, Target.class, interceptorList);
      68.         methodInvocation.proceed();
      69.     }
      70.  
      71.     public static void showDetail(Object o) {
      72.         try {
      73.             Class clazz = Class.forName("org.springframework.aop.framework.InterceptorAndDynamicMethodMatcher");
      74.             if (clazz.isInstance(o)) {
      75.                 Field methodMatcher = clazz.getDeclaredField("methodMatcher");
      76.                 methodMatcher.setAccessible(true);
      77.                 Field interceptor = clazz.getDeclaredField("interceptor");
      78.                 interceptor.setAccessible(true);
      79.                 System.out.println("环绕通知和切点:" + o);
      80.                 System.out.println("\t切点为：" + methodMatcher.get(o));
      81.                 System.out.println("\t通知为：" + interceptor.get(o));
      82.             }else {
      83.                 System.out.println("普通环绕通知：" + o);
      84.             }
      85.         } catch (Exception e) {
      86.             e.printStackTrace();
      87.         }
      88.  
      89.     }
      90. }
        91.  

        结果：
         

        1. 普通环绕通知：org.springframework.aop.interceptor.ExposeInvocationInterceptor@82de64a
        2. 普通环绕通知：org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@659499f1
        3. 环绕通知和切点:org.springframework.aop.framework.InterceptorAndDynamicMethodMatcher@47e2e487
        4. 	切点为：AspectJExpressionPointcut: (int x) execution(* foo(..)) && args(x)
        5. 	通知为：org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@201a4587
        6. before1
        7. before2(100)
        8. target foo(100)
         

        InterceptorAndDynamicMethodMatcher：拦截器和动态的方法匹配器，内部包含了真正的环绕通知和切点，它并不是一个环绕通知，查看它的类就能知道。
         

        1. class InterceptorAndDynamicMethodMatcher {
        2.     // 环绕通知
        3.     final MethodInterceptor interceptor;
        4.     // 切点
        5.     final MethodMatcher methodMatcher;
        6.  
        7.     public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {
        8.         this.interceptor = interceptor;
        9.         this.methodMatcher = methodMatcher;
        10.     }
        11. }
         

        总结：
         

        1.  
          通过 proxyFactory 的 getInterceptorsAndDynamicInterceptionAdvice() 将其他通知统一转换为 MethodInterceptor 环绕通知
           
        2.  
          所谓动态通知，体现在上面方法的 DynamicInterceptionAdvice 部分，这些通知调用时因为要为通知方法绑定参数，还需再次利用切点表达式
           
        3.  
          动态通知调用复杂程度高，性能较低 
           
        
                
                    
                

                
      91. 

                    相关阅读:
        
                    
Python爬虫教程12：从b站获取神仙姐姐的视频弹幕内容                            
        
[hackthebox] Meow                            
        
【MFC】socket通信代码解析                            
        
WebRTC + Tensorflow.js 在运动健康类项目中的前端应用                            
        
力扣（leetcode）第485题最大连续1的个数（Python）                            
        
GB/T 28181联网系统通信协议结构和技术实现                            
        
Java Web 33道面试题汇总                            
        
检测到 #include 错误。请更新 includePath。无法打开 源 文件xxx                            
        
Vue_Bug VUE-ELEMENT-ADMIN默认是英文模式                            
        
python简单使用grpc                            
        
                            
                
        92. 
                
      92. 
                    原文地址：https://blog.csdn.net/qq_51409098/article/details/127729796
                
        93.