SpringAOP模拟实现

文章目录

    • 1_底层切点、通知、切面
    • 2_切点匹配
    • 3_从 @Aspect 到 Advisor
      • 1_代理创建器
      • 2_代理创建时机
      • 3_@Before 对应的低级通知
    • 4_静态通知调用
      • 1_通知调用过程
      • 2_模拟 MethodInvocation
    • 5_动态通知调用

1_底层切点、通知、切面


注意点：

  1. 底层的切点实现
  2. 底层的通知实现
  3. 底层的切面实现
  4. ProxyFactory 用来创建代理
    • 如果指定了接口，且 proxyTargetClass = false，使用 JdkDynamicAopProxy
    • 如果没有指定接口，或者 proxyTargetClass = true，使用 ObjenesisCglibAopProxy
    • 例外：如果目标是接口类型或已经是 jdk 代理，使用 JdkDynamicAopProxy
public class A15 {public static void main(String[] args) {/*两个切面概念aspect =通知1(advice) +  切点1(pointcut)通知2(advice) +  切点2(pointcut)通知3(advice) +  切点3(pointcut)...advisor = 更细粒度的切面，包含一个通知和切点*/// 1. 备好切点AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");// 2. 备好通知MethodInterceptor advice = invocation -> {System.out.println("before...");Object result = invocation.proceed(); // 调用目标System.out.println("after...");return result;};// 3. 备好切面DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);/*4. 创建代理a. proxyTargetClass = false, 目标实现了接口, 用 jdk 实现b. proxyTargetClass = false,  目标没有实现接口, 用 cglib 实现c. proxyTargetClass = true, 总是使用 cglib 实现*/Target2 target = new Target2();ProxyFactory factory = new ProxyFactory();factory.setTarget(target);factory.addAdvisor(advisor);factory.setInterfaces(target.getClass().getInterfaces());factory.setProxyTargetClass(false);Target2 proxy = (Target2) factory.getProxy();System.out.println(proxy.getClass());proxy.foo();proxy.bar();/*学到了什么a. Spring 的代理选择规则b. 底层的切点实现c. 底层的通知实现d. ProxyFactory 是用来创建代理的核心实现, 用 AopProxyFactory 选择具体代理实现- JdkDynamicAopProxy- ObjenesisCglibAopProxy*/}interface I1 {void foo();void bar();}static class Target1 implements I1 {public void foo() {System.out.println("target1 foo");}public void bar() {System.out.println("target1 bar");}}static class Target2 {public void foo() {System.out.println("target2 foo");}public void bar() {System.out.println("target2 bar");}}
}

2_切点匹配


切点匹配：

  1. 常见 aspectj 切点用法
  2. aspectj 切点的局限性，实际的 @Transactional 切点实现
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.StaticMethodMatcherPointcut;
import org.springframework.core.annotation.MergedAnnotations;
import org.springframework.transaction.annotation.Transactional;import java.lang.reflect.Method;public class A16 {public static void main(String[] args) throws NoSuchMethodException {
//        AspectJExpressionPointcut pt1 = new AspectJExpressionPointcut();
//        pt1.setExpression("execution(* bar())");
//        System.out.println(pt1.matches(T1.class.getMethod("foo"), T1.class));
//        System.out.println(pt1.matches(T1.class.getMethod("bar"), T1.class));
//
//        AspectJExpressionPointcut pt2 = new AspectJExpressionPointcut();
//        pt2.setExpression("@annotation(org.springframework.transaction.annotation.Transactional)");
//        System.out.println(pt2.matches(T1.class.getMethod("foo"), T1.class));
//        System.out.println(pt2.matches(T1.class.getMethod("bar"), T1.class));StaticMethodMatcherPointcut pt3 = new StaticMethodMatcherPointcut() {@Overridepublic boolean matches(Method method, Class<?> targetClass) {// 检查方法上是否加了 Transactional 注解MergedAnnotations annotations = MergedAnnotations.from(method);if (annotations.isPresent(Transactional.class)) {return true;}// 查看类上是否加了 Transactional 注解annotations = MergedAnnotations.from(targetClass, MergedAnnotations.SearchStrategy.TYPE_HIERARCHY);if (annotations.isPresent(Transactional.class)) {return true;}return false;}};System.out.println(pt3.matches(T1.class.getMethod("foo"), T1.class));System.out.println(pt3.matches(T1.class.getMethod("bar"), T1.class));System.out.println(pt3.matches(T2.class.getMethod("foo"), T2.class));System.out.println(pt3.matches(T3.class.getMethod("foo"), T3.class));/*学到了什么a. 底层切点实现是如何匹配的: 调用了 aspectj 的匹配方法b. 比较关键的是它实现了 MethodMatcher 接口, 用来执行方法的匹配*/}static class T1 {@Transactionalpublic void foo() {}public void bar() {}}@Transactionalstatic class T2 {public void foo() {}}@Transactionalinterface I3 {void foo();}static class T3 implements I3 {public void foo() {}}
}

3_从 @Aspect 到 Advisor

1_代理创建器


注意点：

  1. AnnotationAwareAspectJAutoProxyCreator 的作用
    • 将高级 @Aspect 切面统一为低级 Advisor 切面。
    • 在合适的时机创建代理。
  2. findEligibleAdvisors 找到有【资格】的 Advisors
    • 有【资格】的 Advisor 一部分是低级的, 可以由自己编写, 如本例 A17 中的 advisor3。
    • 有【资格】的 Advisor 另一部分是高级的, 由解析 @Aspect 后获得。
  3. wrapIfNecessary
    • 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理。
    • 它的调用时机通常在原始对象初始化后执行, 但碰到循环依赖会提前至依赖注入之前执行。
package org.springframework.aop.framework.autoproxy;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.transaction.annotation.Transactional;import java.util.List;/*** @author shenyang* @version 1.0* @info TestAop* @since 2024/8/17 20:26*/
public class A17 {@Aspect//高级切面static class Aspect1{@Before("execution(* foo())")public void before(){System.out.println("aspect1 before.....");}@After("execution(* foo())")public void after(){System.out.println("aspect1 after.....");}}@Configurationstatic class Config {@Bean//低级切面public Advisor advisor3(MethodInterceptor advice3) {AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");return new DefaultPointcutAdvisor(pointcut, advice3);}@Beanpublic MethodInterceptor advice3(){return new MethodInterceptor() {@Overridepublic Object invoke(MethodInvocation methodInvocation) throws Throwable {System.out.println("advice3 before.....");Object proceed = methodInvocation.proceed();System.out.println("advice3 after.....");return proceed;}};}}static class T1 {public void foo() {System.out.println("target1 foo");}}static class T2 {public void bar() {System.out.println("target2 bar");}}public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();context.registerBean("aspect1",Aspect1.class);context.registerBean("config",Config.class);context.registerBean(ConfigurationClassPostProcessor.class);context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);context.refresh();AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);List<Advisor> advisors = creator.findEligibleAdvisors(T2.class, "target2");System.out.println("====================");
//        advisors.forEach(System.out::println);T1 o1 = (T1) creator.wrapIfNecessary(new T1(), "target1", "target1");T2 o2 = (T2) creator.wrapIfNecessary(new T2(), "target2", "target2");System.out.println(o1.getClass()+" "+o2.getClass());o1.foo();o2.bar();}}

2_代理创建时机


注意点：

  1. 代理的创建时机
    • 初始化之后 (无循环依赖时)
    • 实例创建后, 依赖注入前 (有循环依赖时), 并暂存于二级缓存。
  2. 依赖注入与初始化不应该被增强, 仍应被施加于原始对象
package org.springframework.aop.framework.autoproxy;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;import javax.annotation.PostConstruct;public class A17_1 {public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();context.registerBean(ConfigurationClassPostProcessor.class);context.registerBean(Config.class);context.refresh();context.close();// 创建 -> (*) 依赖注入 -> 初始化 (*)/*学到了什么a. 代理的创建时机1. 初始化之后 (无循环依赖时)2. 实例创建后, 依赖注入前 (有循环依赖时), 并暂存于二级缓存b. 依赖注入与初始化不应该被增强, 仍应被施加于原始对象*/}@Configurationstatic class Config {@Bean // 解析 @Aspect、产生代理public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator() {return new AnnotationAwareAspectJAutoProxyCreator();}@Bean // 解析 @Autowiredpublic AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor() {return new AutowiredAnnotationBeanPostProcessor();}@Bean // 解析 @PostConstructpublic CommonAnnotationBeanPostProcessor commonAnnotationBeanPostProcessor() {return new CommonAnnotationBeanPostProcessor();}@Beanpublic Advisor advisor(MethodInterceptor advice) {AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");return new DefaultPointcutAdvisor(pointcut, advice);}@Beanpublic MethodInterceptor advice() {return (MethodInvocation invocation) -> {System.out.println("before...");return invocation.proceed();};}@Beanpublic Bean1 bean1() {return new Bean1();}@Beanpublic Bean2 bean2() {return new Bean2();}}static class Bean1 {public void foo() {}public Bean1() {System.out.println("Bean1()");}@Autowired public void setBean2(Bean2 bean2) {System.out.println("Bean1 setBean2(bean2) class is: " + bean2.getClass());}@PostConstruct public void init() {System.out.println("Bean1 init()");}}static class Bean2 {public Bean2() {System.out.println("Bean2()");}@Autowired public void setBean1(Bean1 bean1) {System.out.println("Bean2 setBean1(bean1) class is: " + bean1.getClass());}@PostConstruct public void init() {System.out.println("Bean2 init()");}}
}

3_@Before 对应的低级通知


注意点：

  1. @Before 前置通知会被转换为原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息
    • 通知代码从哪儿来
    • 切点是什么(这里为啥要切点, 后面解释)
    • 通知对象如何创建, 本例共用同一个 Aspect 对象
  2. 类似的还有
    • AspectJAroundAdvice (环绕通知)
    • AspectJAfterReturningAdvice
    • AspectJAfterThrowingAdvice (环绕通知)
    • AspectJAfterAdvice (环绕通知)
package org.springframework.aop.framework.autoproxy;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectInstanceFactory;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.AspectJMethodBeforeAdvice;
import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;public class A17_2 {static class Aspect {@Before("execution(* foo())")public void before1() {System.out.println("before1");}@Before("execution(* foo())")public void before2() {System.out.println("before2");}public void after() {System.out.println("after");}public void afterReturning() {System.out.println("afterReturning");}public void afterThrowing() {System.out.println("afterThrowing");}public Object around(ProceedingJoinPoint pjp) throws Throwable {try {System.out.println("around...before");return pjp.proceed();} finally {System.out.println("around...after");}}}static class Target {public void foo() {System.out.println("target foo");}}@SuppressWarnings("all")public static void main(String[] args) throws Throwable {AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());// 高级切面转低级切面类List<Advisor> list = new ArrayList<>();for (Method method : Aspect.class.getDeclaredMethods()) {if (method.isAnnotationPresent(Before.class)) {// 解析切点String expression = method.getAnnotation(Before.class).value();AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression(expression);// 通知类AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);// 切面Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);list.add(advisor);}}for (Advisor advisor : list) {System.out.println(advisor);}/*@Before 前置通知会被转换为下面原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息a. 通知代码从哪儿来b. 切点是什么(这里为啥要切点, 后面解释)c. 通知对象如何创建, 本例共用同一个 Aspect 对象类似的通知还有1. AspectJAroundAdvice (环绕通知)2. AspectJAfterReturningAdvice3. AspectJAfterThrowingAdvice4. AspectJAfterAdvice (环绕通知)*/}
}

4_静态通知调用


代理对象调用流程如下（以 JDK 动态代理实现为例）

  • 从 ProxyFactory 获得 Target 和环绕通知链，根据他俩创建 MethodInvocation，简称 mi
  • 首次执行 mi.proceed() 发现有下一个环绕通知，调用它的 invoke(mi)
  • 进入环绕通知1，执行前增强，再次调用 mi.proceed() 发现有下一个环绕通知，调用它的 invoke(mi)
  • 进入环绕通知2，执行前增强，调用 mi.proceed() 发现没有环绕通知，调用 mi.invokeJoinPoint() 执行目标方法
  • 目标方法执行结束，将结果返回给环绕通知2，执行环绕通知2 的后增强
  • 环绕通知2继续将结果返回给环绕通知1，执行环绕通知1 的后增强
  • 环绕通知1返回最终的结果

图中不同颜色对应一次环绕通知或目标的调用起始至终结

Proxy InvocationHandler MethodInvocation ProxyFactory MethodInterceptor1 MethodInterceptor2 Target invoke() 获得 Target 获得 MethodInterceptor 链 创建 mi mi.proceed() invoke(mi) 前增强 mi.proceed() invoke(mi) 前增强 mi.proceed() mi.invokeJoinPoint() 结果 后增强 结果 后增强 结果 Proxy InvocationHandler MethodInvocation ProxyFactory MethodInterceptor1 MethodInterceptor2 Target

1_通知调用过程


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

  1. 通过 proxyFactory 的 getInterceptorsAndDynamicInterceptionAdvice() 将其他通知统一转换为 MethodInterceptor 环绕通知
    • MethodBeforeAdviceAdapter 将 @Before AspectJMethodBeforeAdvice 适配为 MethodBeforeAdviceInterceptor
    • AfterReturningAdviceAdapter 将 @AfterReturning AspectJAfterReturningAdvice 适配为 AfterReturningAdviceInterceptor
    • 这体现的是适配器设计模式
  2. 所谓静态通知，体现在上面方法的 Interceptors 部分，这些通知调用时无需再次检查切点，直接调用即可
  3. 结合目标与环绕通知链，创建 MethodInvocation 对象，通过它完成整个调用
package org.springframework.aop.framework;import org.aopalliance.intercept.MethodInvocation;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.*;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.framework.ReflectiveMethodInvocation;
import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
import org.springframework.aop.support.DefaultPointcutAdvisor;import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;public class A18 {static class Aspect {@Before("execution(* foo())")public void before1() {System.out.println("before1");}@Before("execution(* foo())")public void before2() {System.out.println("before2");}public void after() {System.out.println("after");}@AfterReturning("execution(* foo())")public void afterReturning() {System.out.println("afterReturning");}@AfterThrowing("execution(* foo())")public void afterThrowing(Exception e) {System.out.println("afterThrowing " + e.getMessage());}@Around("execution(* foo())")public Object around(ProceedingJoinPoint pjp) throws Throwable {try {System.out.println("around...before");return pjp.proceed();} finally {System.out.println("around...after");}}}static class Target {public void foo() {System.out.println("target foo");}}@SuppressWarnings("all")public static void main(String[] args) throws Throwable {AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());// 1. 高级切面转低级切面类List<Advisor> list = new ArrayList<>();for (Method method : Aspect.class.getDeclaredMethods()) {if (method.isAnnotationPresent(Before.class)) {// 解析切点String expression = method.getAnnotation(Before.class).value();AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression(expression);// 通知类AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);// 切面Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);list.add(advisor);} else if (method.isAnnotationPresent(AfterReturning.class)) {// 解析切点String expression = method.getAnnotation(AfterReturning.class).value();AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression(expression);// 通知类AspectJAfterReturningAdvice advice = new AspectJAfterReturningAdvice(method, pointcut, factory);// 切面Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);list.add(advisor);} else if (method.isAnnotationPresent(Around.class)) {// 解析切点String expression = method.getAnnotation(Around.class).value();AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression(expression);// 通知类AspectJAroundAdvice advice = new AspectJAroundAdvice(method, pointcut, factory);// 切面Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);list.add(advisor);}}for (Advisor advisor : list) {System.out.println(advisor);}/*@Before 前置通知会被转换为下面原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息a. 通知代码从哪儿来b. 切点是什么c. 通知对象如何创建, 本例共用同一个 Aspect 对象类似的通知还有1. AspectJAroundAdvice (环绕通知)2. AspectJAfterReturningAdvice3. AspectJAfterThrowingAdvice (环绕通知)4. AspectJAfterAdvice (环绕通知)*/// 2. 通知统一转换为环绕通知 MethodInterceptor/*其实无论 ProxyFactory 基于哪种方式创建代理, 最后干活(调用 advice)的是一个 MethodInvocation 对象a. 因为 advisor 有多个, 且一个套一个调用, 因此需要一个调用链对象, 即 MethodInvocationb. MethodInvocation 要知道 advice 有哪些, 还要知道目标, 调用次序如下将 MethodInvocation 放入当前线程|-> before1 ----------------------------------- 从当前线程获取 MethodInvocation|                                             ||   |-> before2 --------------------          | 从当前线程获取 MethodInvocation|   |                              |          ||   |   |-> target ------ 目标   advice2    advice1|   |                              |          ||   |-> after2 ---------------------          ||                                             ||-> after1 ------------------------------------c. 从上图看出, 环绕通知才适合作为 advice, 因此其他 before、afterReturning 都会被转换成环绕通知d. 统一转换为环绕通知, 体现的是设计模式中的适配器模式- 对外是为了方便使用要区分 before、afterReturning- 对内统一都是环绕通知, 统一用 MethodInterceptor 表示此步获取所有执行时需要的 advice (静态)a. 即统一转换为 MethodInterceptor 环绕通知, 这体现在方法名中的 Interceptors 上b. 适配如下- MethodBeforeAdviceAdapter 将 @Before AspectJMethodBeforeAdvice 适配为 MethodBeforeAdviceInterceptor- AfterReturningAdviceAdapter 将 @AfterReturning AspectJAfterReturningAdvice 适配为 AfterReturningAdviceInterceptor*/Target target = new Target();ProxyFactory proxyFactory = new ProxyFactory();proxyFactory.setTarget(target);proxyFactory.addAdvice(ExposeInvocationInterceptor.INSTANCE); // 准备把 MethodInvocation 放入当前线程proxyFactory.addAdvisors(list);System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");List<Object> methodInterceptorList = proxyFactory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo"), Target.class);for (Object o : methodInterceptorList) {System.out.println(o);}System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");// 3. 创建并执行调用链 (环绕通知s + 目标)MethodInvocation methodInvocation = new ReflectiveMethodInvocation(null, target, Target.class.getMethod("foo"), new Object[0], Target.class, methodInterceptorList);methodInvocation.proceed();/*学到了什么a. 无参数绑定的通知如何被调用b. MethodInvocation 编程技巧: 拦截器、过滤器等等实现都与此类似c. 适配器模式在 Spring 中的体现*/}
}

2_模拟 MethodInvocation


注意点：

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

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

package org.springframework.aop.framework;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;/*模拟调用链过程, 是一个简单的递归过程1. proceed() 方法调用链中下一个环绕通知2. 每个环绕通知内部继续调用 proceed()3. 调用到没有更多通知了, 就调用目标方法*/
public class A18_1 {static class Target {public void foo() {System.out.println("Target.foo()");}}static class Advice1 implements MethodInterceptor {public Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("Advice1.before()");Object result = invocation.proceed();// 调用下一个通知或目标System.out.println("Advice1.after()");return result;}}static class Advice2 implements MethodInterceptor {public Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("Advice2.before()");Object result = invocation.proceed();// 调用下一个通知或目标System.out.println("Advice2.after()");return result;}}static class MyInvocation implements MethodInvocation {private Object target;  // 1private Method method;private Object[] args;List<MethodInterceptor> methodInterceptorList; // 2private int count = 1; // 调用次数public MyInvocation(Object target, Method method, Object[] args, List<MethodInterceptor> methodInterceptorList) {this.target = target;this.method = method;this.args = args;this.methodInterceptorList = methodInterceptorList;}@Overridepublic Method getMethod() {return method;}@Overridepublic Object[] getArguments() {return args;}@Overridepublic Object proceed() throws Throwable { // 调用每一个环绕通知, 调用目标if (count > methodInterceptorList.size()) {// 调用目标， 返回并结束递归return method.invoke(target, args);}// 逐一调用通知, count + 1MethodInterceptor methodInterceptor = methodInterceptorList.get(count++ - 1);return methodInterceptor.invoke(this);}@Overridepublic Object getThis() {return target;}@Overridepublic AccessibleObject getStaticPart() {return method;}}public static void main(String[] args) throws Throwable {Target target = new Target();List<MethodInterceptor> list = new ArrayList<>();list.add(new Advice1());list.add(new Advice2());MyInvocation invocation = new MyInvocation(target, Target.class.getMethod("foo"), new Object[0], list);invocation.proceed();}
}

5_动态通知调用


注意点：

  1. 通过 proxyFactory 的 getInterceptorsAndDynamicInterceptionAdvice() 将其他通知统一转换为 MethodInterceptor 环绕通知
  2. 所谓动态通知，体现在上面方法的 DynamicInterceptionAdvice 部分，这些通知调用时因为要为通知方法绑定参数，还需再次利用切点表达式
  3. 动态通知调用复杂程度高，性能较低
package org.springframework.aop.framework.autoproxy;import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.framework.ReflectiveMethodInvocation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;import java.lang.reflect.Field;
import java.util.List;public class A19 {@Aspectstatic class MyAspect {@Before("execution(* foo(..))") // 静态通知调用，不带参数绑定，执行时不需要切点public void before1() {System.out.println("before1");}@Before("execution(* foo(..)) && args(x)") // 动态通知调用，需要参数绑定，执行时还需要切点对象public void before2(int x) {System.out.printf("before2(%d)%n", x);}}static class Target {public void foo(int x) {System.out.printf("target foo(%d)%n", x);}}@Configurationstatic class MyConfig {@BeanAnnotationAwareAspectJAutoProxyCreator proxyCreator() {return new AnnotationAwareAspectJAutoProxyCreator();}@Beanpublic MyAspect myAspect() {return new MyAspect();}}public static void main(String[] args) throws Throwable {GenericApplicationContext context = new GenericApplicationContext();context.registerBean(ConfigurationClassPostProcessor.class);context.registerBean(MyConfig.class);context.refresh();AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);List<Advisor> list = creator.findEligibleAdvisors(Target.class, "target");Target target = new Target();ProxyFactory factory = new ProxyFactory();factory.setTarget(target);factory.addAdvisors(list);Object proxy = factory.getProxy(); // 获取代理List<Object> interceptorList = factory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo", int.class), Target.class);for (Object o : interceptorList) {showDetail(o);}System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>");ReflectiveMethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, Target.class.getMethod("foo", int.class), new Object[]{100}, Target.class, interceptorList) {};invocation.proceed();/*学到了什么a. 有参数绑定的通知调用时还需要切点，对参数进行匹配及绑定b. 复杂程度高, 性能比无参数绑定的通知调用低*/}public static void showDetail(Object o) {try {Class<?> clazz = Class.forName("org.springframework.aop.framework.InterceptorAndDynamicMethodMatcher");if (clazz.isInstance(o)) {Field methodMatcher = clazz.getDeclaredField("methodMatcher");methodMatcher.setAccessible(true);Field methodInterceptor = clazz.getDeclaredField("interceptor");methodInterceptor.setAccessible(true);System.out.println("环绕通知和切点：" + o);System.out.println("\t切点为：" + methodMatcher.get(o));System.out.println("\t通知为：" + methodInterceptor.get(o));} else {System.out.println("普通环绕通知：" + o);}} catch (Exception e) {e.printStackTrace();}}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/19502.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

java语言输入两个整数a，b，输出a/b的值，只保留整数部分

java语言输入两个整数a，b，输出a/b的值，只保留整数部分

除法取整用强制转换int number (int) c;
阅读更多...
【MySQL系列】深入理解MySQL中的存储、排序字符集

【MySQL系列】深入理解MySQL中的存储、排序字符集

前言 在创建数据库时&#xff0c;我们经常会需要填写数据库的所用字符集、排序规则&#xff0c;字符集和排序规则是两个非常重要的概念&#xff0c;它们决定了数据库如何存储和比较字符串数据。在 MySQL 中&#xff0c;常用的存储字符集有 utf8、utf8mb4&#xff0c;而排序字符…
阅读更多...
tcp 超时计时器

tcp 超时计时器

在 TCP&#xff08;传输控制协议&#xff09;中有以下四种重要的计时器&#xff1a; 重传计时器&#xff08;Retransmission Timer&#xff09; 作用&#xff1a;用于处理数据包丢失的情况。当发送方发送一个数据段后&#xff0c;就会启动重传计时器。如果在计时器超时之前没有…
阅读更多...
Docker部署ES7.9.3单节点

Docker部署ES7.9.3单节点

Elasticsearch&#xff08;简称ES&#xff09;是一个分布式、可扩展、实时的搜索与数据分析引擎&#xff01; Elasticsearch位于Elastic Stack核心&#xff0c;为所有类型的数据提供近乎实时的搜索和分析。无论是结构化或非结构化文本、数字数据还是地理空间数据&#xff0c;El…
阅读更多...
ChromeDriver驱动下载地址更新（保持最新最全）

ChromeDriver驱动下载地址更新（保持最新最全）

说明&#xff1a; ChromeDriver 是 Selenium WebDriver 用于控制 Chrome 的独立可执行文件。 为了方便下载使用&#xff0c;本文保持ChromeDriver的最新版本更新&#xff0c;并提供115.0.5763.0-133.0.6841.0版本的下载地址&#xff1a; 所有版本和下载地址&#xff1a; &am…
阅读更多...
CSS：高级寄巧

CSS：高级寄巧

精灵图 为什么需要精灵图呢&#xff1f; 一个网页中往往会应用很多小背景图作为修饰&#xff0c;当网页中的图像过多时&#xff0c;服务器就会频繁地接收和发送 请求图片&#xff0c;造成服务器请求压力过大&#xff0c;这将大大降低页面的加载速度。 因此&#xff0c;为了有…
阅读更多...
linux002.虚拟机中ubuntu容量不够，新增容量合并的方法

linux002.虚拟机中ubuntu容量不够，新增容量合并的方法

新增容量合并方法
阅读更多...
AutosarMCAL开发——基于EB DsAdc驱动

AutosarMCAL开发——基于EB DsAdc驱动

目录 一、旋转变压器与DsAdc原理1.常见电机角度反馈方式2.可变磁阻旋变工作原理3.使用TC3XX EDSADC进行旋变软解码 二、EB配置1.载波输出2.通道配置3.调制器4.滤波链路5.整流6.积分 三、Mcal接口应用1.AUtosar标准API接口2.应用步骤 四、总结 一、旋转变压器与DsAdc原理 1.常见…
阅读更多...
web应用安全和信息泄露预防

web应用安全和信息泄露预防

文章目录 1&#xff1a;spring actuator导致的信息泄露1.1、Endpoint配置启用检测1.2、信息泄露复现1.3、防御 2&#xff1a;服务端口的合理使用3&#xff1a;弱口令&#xff08;密码&#xff09;管理4&#xff1a;服务端攻击4.1、短信业务&#xff0c;文件上传等资源型接口1、…
阅读更多...
C语言：链表

C语言：链表

链表是一种常见的线性数据结构&#xff0c;其中每个元素&#xff08;称为节点&#xff09;包含两部分&#xff1a;数据和指向下一个节点的指针。链表的主要优点是插入和删除操作的时间复杂度较低&#xff0c;但随机访问的效率不如数组。 1. 链表的基本概念 节点&#xff08;N…
阅读更多...
webpack配置

webpack配置

4-3vue-loader测试_哔哩哔哩_bilibili 一.新建文件夹vue_todo&#xff0c;vscode打开 二.ctrl打开终端&#xff0c;输入npm init -y&#xff0c;快速生成一个默认的package.json文件 之后左边出现项目初始化文件package.json 三.接下来需要webpack完成打包&#xff0c;所以安装…
阅读更多...
字节跳动辞退103人

字节跳动辞退103人

大家好&#xff0c;我是程序员面试刷题平台的鸭鸭&#xff01; 在前阵子实习生破坏大模型训练事件之后&#xff0c;字节又上了一次热搜。 鸭鸭吃完瓜&#xff0c;只能说&#xff0c;社会险恶啊同学们&#xff01; 5 号&#xff0c;字节跳动内部发布了年内第四份《企业纪律与职…
阅读更多...
大型语言模型综述 A Survey of Large Language Models

大型语言模型综述 A Survey of Large Language Models

文章源自 2303.18223 (arxiv.org) 如有侵权&#xff0c;请通知下线 这是一篇关于大语言模型&#xff08;LLMs&#xff09;的综述论文&#xff0c;主要介绍了 LLMs 的发展历程、技术架构、训练方法、应用领域以及面临的挑战等方面&#xff0c;具体内容如下&#xff1a; 摘要…
阅读更多...
服务器作业4

服务器作业4

[rootlocalhost day04]# vim 10.sh [rootlocalhost day04]# cat 10.sh #通过shell脚本分析部署nginx网络服务 #1.接收用户部署的服务名称 read -p "服务名称:(nginx)" server if [ $server ! nginx ];then echo "输入的不是nginx,脚本退出" exit 1…
阅读更多...
Linux基础（二十）——程序管理与 SELinux 初探

Linux基础（二十）——程序管理与 SELinux 初探

程序管理与 SELinux 初探 1. 程序和进程2.程序调用流程3. 一个bash中的多任务工作管理4.进程管理4.1 查询进程4.2 进程的执行顺序 5.系统资源的观察6. /proc/* 代表的意义7.SELinux 1. 程序和进程 2.程序调用流程 程序与进程之间的关系&#xff1a; 从上图可以看出&#xff0…
阅读更多...
vue3 路由写法及传参方式 !超详细

vue3 路由写法及传参方式 !超详细

Vue Router 是 Vue.js 官方的路由管理器。它主要用于单页面应用程序&#xff08;SPA, Single Page Application&#xff09;中&#xff0c;帮助解决页面导航、组件复用等问题。 基本的使用 1.router配置文件代码 创建一个ts文件,用来写路由器 // 创建一个路由器,并暴露出去 …
阅读更多...
MATLAB绘制正四面体、正六面体

MATLAB绘制正四面体、正六面体

MATLAB绘制正四面体、正六面体 clc;close all;clear all;warning off;% clear all rand(seed, 100); randn(seed, 100); format long g;% 正四面体&#xff08;Tetrahedron&#xff09; % 顶点坐标&#xff08;正四面体的顶点位于一个正方体的对角线上&#xff0c;并经过适当缩…
阅读更多...
一文了解 inductive bias（归纳偏好）

一文了解 inductive bias（归纳偏好）

&#x1f349; CSDN 叶庭云&#xff1a;https://yetingyun.blog.csdn.net/ 归纳偏好&#xff08;Inductive Bias&#xff09;是机器学习中的一个非常基础但又非常重要的概念。为了更好地理解它&#xff0c;我们先从 “归纳” 和 “偏好” 这两个词开始讲解。 什么是归纳&#x…
阅读更多...
leetcode844:比较含退格的字符串

leetcode844:比较含退格的字符串

题干 题目分析 两个字符串要进行比较&#xff0c;#代表着回车&#xff0c;也就是删除之前的字符。 若按照遍历的惯例&#xff0c;选择从前到后遍历&#xff0c;但这样没法判断&#xff0c;因为#之前被删除的部分是不需要相同的。 因此考虑到#的含义&#xff0c;我们应该选择从…
阅读更多...
【Python爬虫实战】从入门到精通：全面解析IP代理池的原理与实战应用

【Python爬虫实战】从入门到精通：全面解析IP代理池的原理与实战应用

&#x1f308;个人主页&#xff1a;易辰君-CSDN博客 &#x1f525; 系列专栏&#xff1a;https://blog.csdn.net/2401_86688088/category_12797772.html ​ 目录 前言 一、IP代理池 &#xff08;一&#xff09;基本概念 &#xff08;二&#xff09;主要功能 &#xff08;三…
阅读更多...
最新文章

Copyright @ 2022~2023