Spring AOP低级切面到高级切面详解

Aop基础

ps:欢迎指正错误，涉及了一点点Spring后置处理器的扫描的内容

@AspectstaticclassAspect1{@org.aspectj.lang.annotation.Before("execution(* foo())")publicvoidbefore1(){System.out.println("before1");}}

一个简单的aop类-spring advisor使用

连接点实现

Pointcut是用来描述“哪些类的哪些方法需要被代理增强”的规则。

public interface Pointcut { Pointcut TRUE = TruePointcut.INSTANCE; ​ ClassFilter getClassFilter(); // 过滤类 ​ MethodMatcher getMethodMatcher();// 过滤方法 } ClassFilter：决定哪些类匹配 MethodMatcher：决定哪些方法匹配 两者共同决定拦截范围。

切点表达式

切点表达式是在描述匹配规则

execution(*com.xxx.service.*.*(..))

哪些方法需要被织入 advice（通知）

把 method/class 匹配规则用代码封装成 Pointcut 对象而已。

这是 AOP 执行链的核心：

每次方法被代理后，都会被包装成一次invoke()调用。

Advisor：Pointcut + MethodInterceptor

MethodInterceptor：增强逻辑（通知）
Proxy：基于 Advisor 判断是否拦截并执行 interceptor.invoke()

代理对象拦截方法 构造一个MethodInvocation调用 interceptor.invoke(invocation)在这个方法里面你可以写增强逻辑 真正执行目标方法是 invocation.proceed()

///通知@FunctionalInterfacepublicinterfaceMethodInterceptorextendsInterceptor{@NullableObjectinvoke(@NonnullMethodInvocationinvocation)throwsThrowable;}

publicclassLoggingInterceptorimplementsMethodInterceptor{//类似与逻辑点 增强处@OverridepublicObjectinvoke(MethodInvocationinvocation)throwsThrowable{System.out.println("方法执行前日志");// 前置增强Objectresult=invocation.proceed();// 调用目标方法System.out.println("方法执行后日志");returnresult;}}

调用方法 AOP 判断：此方法是否匹配Pointcut匹配 → 调用MethodInterceptor.invoke()invoke()内部调用proceed()执行目标方法proceed()执行完后再执行后置增强

//简单切面

1.流程1

方法调用流程

2.流传2

代理类组织阶段

3 流程3

切面组织流程

publicstaticvoidmain(String[]args){// 1. 备好切点AspectJExpressionPointcutpointcut=newAspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");///表达式转为pointcut对象// 2. 备好通知MethodInterceptoradvice=invocation->{System.out.println("before...");Objectresult=invocation.proceed();// 调用目标System.out.println("after...");returnresult;};///通知也做到了 连接点（JoinPoint）：被增强的方法执行点// 3. 备好切面DefaultPointcutAdvisoradvisor=newDefaultPointcutAdvisor(pointcut,advice);///切面 这是 AOP 的最小工作单元。Target2target=newTarget2();///配置代理工厂ProxyFactoryfactory=newProxyFactory();//设置目标factory.setTarget(target);//设置切面factory.addAdvisor(advisor);Target2proxy=(Target2)factory.getProxy();/* 4. 创建代理 a. proxyTargetClass = false, 目标实现了接口, 用 jdk 实现 b. proxyTargetClass = false, 目标没有实现接口, 用 cglib 实现 c. proxyTargetClass = true, 总是使用 cglib 实现 */System.out.println(proxy.getClass());proxy.foo();proxy.bar();}

class com.itheima.a15.A15$Target2$$EnhancerBySpringCGLIB$$ea384bdf before... target2 foo after... target2 bar

表达式解析 →PointcutMethodInterceptor→ 通知逻辑Pointcut+Advice→Advisor↓ProxyFactory↓ 创建代理对象（JDK/CGLIB） ↓ 调用方法 ↓ 匹配切点？ 是 → 调用 advice.invoke()beforeproceed()→ 调用真实方法 after 否 → 直接执行真实方法

代理实现选择

/* 4. 创建代理 a. proxyTargetClass = false, 目标实现了接口, 用 jdk 实现 b. proxyTargetClass = false, 目标没有实现接口, 用 cglib 实现 c. proxyTargetClass = true, 总是使用 cglib 实现 */

jdk代理使用

Target1target=newTarget1();ProxyFactoryfactory=newProxyFactory();factory.setTarget(target);factory.addAdvisor(advisor);factory.setInterfaces(target.getClass().getInterfaces());factory.setProxyTargetClass(false);I1proxy=(I1)factory.getProxy();System.out.println(proxy.getClass());proxy.foo();proxy.bar();

class com.itheima.a15.$Proxy2 before... target1 foo after... target1 bar

a. Spring 的代理选择规则 b. 底层的切点实现 c. 底层的通知实现 d. ProxyFactory 是用来创建代理的核心实现, 用 AopProxyFactory 选择具体代理实现 - JdkDynamicAopProxy - ObjenesisCglibAopProxy

准备aop

创建代理-代理原始类，创建切点 通知 放入创建的切面，由代理类来进行匹配，成功就调用切莫的通知内的代码，没有就调用元方法

切点匹配

切点匹配///1.根据方法名字增强AspectJExpressionPointcutpt1=newAspectJExpressionPointcut();pt1.setExpression("execution(* bar())");System.out.println(pt1.matches(T1.class.getMethod("foo"),T1.class));falseSystem.out.println(pt1.matches(T1.class.getMethod("bar"),T1.class));true

///根据注解匹配AspectJExpressionPointcutpt2=newAspectJExpressionPointcut();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));

staticclassT1{@Transactionalpublicvoidfoo(){}publicvoidbar(){}}

事务不是这样实现–只能匹配方法-事务有类和接口

事务实现扫描

staticclassT1{@Transactionalpublicvoidfoo(){}publicvoidbar(){}}@TransactionalstaticclassT2{publicvoidfoo(){}}@TransactionalinterfaceI3{voidfoo();}staticclassT3implementsI3{publicvoidfoo(){}}

实现注解扫描 重写matches方法

StaticMethodMatcherPointcutpt3=newStaticMethodMatcherPointcut(){@Overridepublicbooleanmatches(Methodmethod,Class<?>targetClass){// 检查方法上是否加了 Transactional 注解MergedAnnotationsannotations=MergedAnnotations.from(method);if(annotations.isPresent(Transactional.class)){returntrue;}// 查看类上是否加了 Transactional 注解annotations=MergedAnnotations.from(targetClass,MergedAnnotations.SearchStrategy.TYPE_HIERARCHY);if(annotations.isPresent(Transactional.class)){returntrue;}returnfalse;}};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));

从Aspect到advisor

高级的@aspect介绍

低级的advisor介绍

高级切面

本质还是转为低级切面处理

低级切面

1.切入点

// 1. 备好切点AspectJExpressionPointcutpointcut=newAspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");// 2. 备好通知MethodInterceptoradvice=invocation->{System.out.println("before...");Objectresult=invocation.proceed();// 调用目标System.out.println("after...");returnresult;};// 3. 备好切面DefaultPointcutAdvisoradvisor=newDefaultPointcutAdvisor(pointcut,advice);切点-通知-切面

切面

通知

test

Target1target=newTarget1();ProxyFactoryfactory=newProxyFactory();factory.setTarget(target);factory.addAdvisor(advisor);factory.setInterfaces(target.getClass().getInterfaces());///如果 Target2 没有实现任何接口 → 会抛异常（JDK 代理没法用）。factory.setProxyTargetClass(false);I1proxy=(I1)factory.getProxy();System.out.println(proxy.getClass());proxy.foo();proxy.bar();

测试

// 代理能否重复被代理publicclassA15_1{publicstaticvoidmain(String[]args){GenericApplicationContextcontext=newGenericApplicationContext();context.registerBean("myConfig",MyConfig.class);context.registerBean(ConfigurationClassPostProcessor.class);context.registerBean("aspect1",Aspect1.class);context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);//切面扫描context.refresh();Bean1bean1=context.getBean(Bean1.class);bean1.foo();System.out.println(bean1.getClass());// 此代理是为了解决功能增强问题System.out.println(context.getBean("scopedTarget.bean1").getClass());}staticclassMyConfig{// 此代理是为了解决单例注入多例问题@Bean@Scope(proxyMode=ScopedProxyMode.TARGET_CLASS)publicBean1bean1(){returnnewBean1();}}staticclassBean1{publicvoidfoo(){System.out.println("bean1 foo");}}@Aspect//注解扫描staticclassAspect1{@Around("execution(* foo())")publicObjectbefore(ProceedingJoinPointpjp)throwsThrowable{System.out.println("aspect1 around");returnpjp.proceed();}}}

AnnotationAwareAspectJAutoProxyCreator 扫描了aop的注解

使用aop的后缀处理器**

Bean测试

GenericApplicationContextcontext=newGenericApplicationContext();context.registerBean("aspect1",Aspect1.class);context.registerBean("config",Config.class);context.registerBean(ConfigurationClassPostProcessor.class);context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);// BeanPostProcessor// 创建 -> (*) 依赖注入 -> 初始化 (*)context.refresh();

AnnotationAwareAspectJAutoProxyCreator切面类处理

bean后置处理器 作用-找到切面
高级切面转换低级切面
根据切面创建代理对象

发现处理器阶段

扩展点

创建 -> (*) 依赖注入 -> 初始化 (*)

主动调用bean处理器

作用 : 找到有资格的切面类-查找低级切面-高级切面需要转换

自己调用 查看哪些切面内匹配上了

AnnotationAwareAspectJAutoProxyCreatorcreator=context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);List<Advisor>advisors=creator.findEligibleAdvisors(Target2.class,"target2");for(Advisoradvisor:advisors){System.out.println(advisor);}

创建代理
有资格的切面创建代理

第二个重要方法 wrapIfNecessary a. 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理

Objecto1=creator.wrapIfNecessary(newTarget1(),"target1","target1");/// 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理System.out.println(o1.getClass());Objecto2=creator.wrapIfNecessary(newTarget2(),"target2","target2");System.out.println(o2.getClass());((Target1)o1).foo();

classorg.springframework.aop.framework.autoproxy.A17$Target1$$EnhancerBySpringCGLIB$$5748c5d2//代理classorg.springframework.aop.framework.autoproxy.A17$Target2///原始aspect1 before1...aspect1 before2...advice3 before...target1 foo advice3 after...

代理创建调用

是否有必要创建代理

代理创建时间

创建 -> () 依赖注入 -> 初始化 ()

情况1

@Configuration@BeanpublicAdvisoradvisor(MethodInterceptoradvice){AspectJExpressionPointcutpointcut=newAspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");returnnewDefaultPointcutAdvisor(pointcut,advice);}@BeanpublicMethodInterceptoradvice(){return(MethodInvocationinvocation)->{System.out.println("before...");returninvocation.proceed();};}@BeanpublicBean1bean1(){returnnewBean1();}@BeanpublicBean2bean2(){returnnewBean2();}}//代理staticclassBean1{publicvoidfoo(){}publicBean1(){System.out.println("Bean1()");}@PostConstructpublicvoidinit(){//初始化System.out.println("Bean1 init()");}}staticclassBean2{publicBean2(){System.out.println("Bean2()");}@AutowiredpublicvoidsetBean1(Bean1bean1){System.out.println("Bean2 setBean1(bean1) class is: "+bean1.getClass());}@PostConstructpublicvoidinit(){System.out.println("Bean2 init()");}}publicstaticvoidmain(String[]args){GenericApplicationContextcontext=newGenericApplicationContext();context.registerBean(ConfigurationClassPostProcessor.class);context.registerBean(Config.class);//配置类context.refresh();context.close();}

Bean1()构造Bean1init()初始化[TRACE]17:15:47.625[main]o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator-Creatingimplicit proxyforbean'bean1'with0common interceptors and2specific interceptors/// 创建了bean1的代理对象，并且放入容器中Bean2()Bean2setBean1(bean1)classis:classorg.springframework.aop.framework.autoproxy.A17_1$Bean1$$EnhancerBySpringCGLIB$$2fba3bac/// 把bean1的代理对象注入进去Bean2init()初始化

情况2

代理创建时机

循环依赖

Bean1()Bean2()[TRACE]17:17:14.751[main]o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator-Creatingimplicit proxyforbean'bean1'with0common interceptors and2specific interceptorsBean2setBean1(bean1)classis:classorg.springframework.aop.framework.autoproxy.A17_1$Bean1$$EnhancerBySpringCGLIB$$df1706a0//注入代理对象bean1 bean1提前创建,再初始化前Bean2init()///Bean1setBean2(bean2)classis:classorg.springframework.aop.framework.autoproxy.A17_1$Bean2///再次注入bean2Bean1init()

使用了延迟加载技术,也就是搭了个壳子,但是内容不完整,.之后大家创建好了,再补回去

order注解

@Aspect// 高级切面类@Order(1)staticclassAspect1{@Before("execution(* foo())")publicvoidbefore1(){System.out.println("aspect1 before1...");}@Before("execution(* foo())")publicvoidbefore2(){System.out.println("aspect1 before2...");}}

@Bean// 低级切面publicAdvisoradvisor3(MethodInterceptoradvice3){AspectJExpressionPointcutpointcut=newAspectJExpressionPointcut();pointcut.setExpression("execution(* foo())");DefaultPointcutAdvisoradvisor=newDefaultPointcutAdvisor(pointcut,advice3);advisor.setOrder(0);returnadvisor;}

控制切面顺序 @Order(1) advisor.setOrder(0);

默认低级优先级高

高级切面转换低级切面

定义通知和切面连接点

staticclassAspect{@Before("execution(* foo())")publicvoidbefore1(){System.out.println("before1");}@Before("execution(* foo())")publicvoidbefore2(){System.out.println("before2");}}

test测试

找到类-解析切点，创建切点表达式， 创建通知 创建切面类

publicstaticvoidmain(String[]args)throwsThrowable{//切面实例工厂AspectInstanceFactoryfactory=newSingletonAspectInstanceFactory(newAspect());// 高级切面转低级切面类List<Advisor>list=newArrayList<>();for(Methodmethod:Aspect.class.getDeclaredMethods()){//方法解析if(method.isAnnotationPresent(Before.class)){// 解析切点Stringexpression=method.getAnnotation(Before.class).value();AspectJExpressionPointcutpointcut=newAspectJExpressionPointcut();pointcut.setExpression(expression);//设计切点// 通知类的创建--前置通知AspectJMethodBeforeAdviceadvice=newAspectJMethodBeforeAdvice(method,pointcut,factory);// 切面Advisoradvisor=newDefaultPointcutAdvisor(pointcut,advice);list.add(advisor);}}for(Advisoradvisor:list){System.out.println(advisor);}}

org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void org.springframework.aop.framework.autoproxy.A17_2$Aspect.before1()]; aspect name ''] ------------------------------------------ org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void org.springframework.aop.framework.autoproxy.A17_2$Aspect.before2()]; aspect name ''] ------------------------------------------

都从高级切面转换成了低级切面

静态通知调用

A18代码

其实无论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表示

18_1

a19