spring 18 动态通知调用

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

点击查看代码

1. @Aspect
2.     static class MyAspect {
3.         @Before("execution(* foo(..))") // 静态通知调用，不带参数绑定，执行时不需要切点
4.         public void before1() {
5.             System.out.println("before1");
6.         }
8.         @Before("execution(* foo(..)) && args(x)") // 动态通知调用，需要参数绑定，执行时还需要切点对象
9.         public void before2(int x) {
10.             System.out.printf("before2(%d)%n", x);
11.         }
12.     }
14.     static class Target {
15.         public void foo(int x) {
16.             System.out.printf("target foo(%d)%n", x);
17.         }
18.     }
20.     @Configuration
21.     static class MyConfig {
22.         @Bean
23.         AnnotationAwareAspectJAutoProxyCreator proxyCreator() {
24.             return new AnnotationAwareAspectJAutoProxyCreator();
25.         }
27.         @Bean
28.         public MyAspect myAspect() {
29.             return new MyAspect();
30.         }
31.     }
33.     public static void main(String[] args) throws Throwable {
34.         GenericApplicationContext context = new GenericApplicationContext();
35.         context.registerBean(ConfigurationClassPostProcessor.class);
36.         context.registerBean(MyConfig.class);
37.         context.refresh();
39.         AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
40.         List<Advisor> list = creator.findEligibleAdvisors(Target.class, "target");
42.         Target target = new Target();
43.         ProxyFactory factory = new ProxyFactory();
44.         factory.setTarget(target);
45.         factory.addAdvisors(list);
46.         Object proxy = factory.getProxy(); // 获取代理
48.         List<Object> interceptorList =
49.                 factory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod(
50.                         "foo", int.class), Target.class);
51.         for (Object o : interceptorList) {
52.             showDetail(o);
53.         }
55.         System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>");
56.         ReflectiveMethodInvocation invocation = new ReflectiveMethodInvocation(
57.                 proxy, target, Target.class.getMethod("foo", int.class),
58.                 new Object[]{100}, Target.class, interceptorList
59.         ) {}; // spring 内部可以创建匿名子类来创建构造器 protected 的对象
61.         invocation.proceed();
63.         /*
64.             学到了什么
65.                 a. 有参数绑定的通知调用时还需要切点，对参数进行匹配及绑定
66.                 b. 复杂程度高, 性能比无参数绑定的通知调用低
67.          */
68.     }
70.     public static void showDetail(Object o) {
71.         try {
72.             Class<?> clazz = Class.forName("org.springframework.aop.framework.InterceptorAndDynamicMethodMatcher");
73.             if (clazz.isInstance(o)) {
74.                 Field methodMatcher = clazz.getDeclaredField("methodMatcher");
75.                 methodMatcher.setAccessible(true);
76.                 Field methodInterceptor = clazz.getDeclaredField("interceptor");
77.                 methodInterceptor.setAccessible(true);
78.                 System.out.println("环绕通知和切点：" + o);
79.                 System.out.println("\t切点为：" + methodMatcher.get(o));
80.                 System.out.println("\t通知为：" + methodInterceptor.get(o));
81.             } else {
82.                 System.out.println("普通环绕通知：" + o);
83.             }
84.         } catch (Exception e) {
85.             e.printStackTrace();
86.         }
87.     }

复制代码

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

”匿名子类写法“：

可参考：https://blog.csdn.net/weixin_39570751/article/details/121253167
点击查看代码

1. class S18Bean1 {
2.     public S18Bean1() {
4.     }
6.     public void add() {
7.     }
8. }

复制代码

1. public class S18Bean2 {
2.     public static void main(String[] args) {
3.         S18Bean1 s18Bean3 = new S18Bean1() {
5.         };
6.         S18Bean1 s18Bean2 = new S18Bean1() {
8.         };
9.         System.out.println(s18Bean3.getClass().getName());
10.         System.out.println(s18Bean2.getClass().getName());
11.     }
12. }

复制代码

在哪个类创建的就以哪个类开头加$数字再加一个空字符命名，Class类的 getSimpleName() 为空，所以真正的名字是空，是匿名的。点击查看代码

一个包下的字包不属于当前包，当前包中的 protect 成员不能被子包访问。
如果里面有个类有个 protect 修饰的构造器 在子包中访问不了，spring 内部就是通过这个办法创建它的子类调用

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！