一文学习 Spring AOP 源码全过程

袁可佳 · 3 天前

Spring AOP 各阶段的流程图

简而言之, 可以分为三步走
一是 spring 如何解析配置, 如何封装关于AOP概念配置对象的?
二是 spring 如何根据配置对象创建代理对象?
三是调用代理对象方法的过程, spring 是如何拦截的?
一、AOP 相关配置的解析过程 (XML)

https://img2024.cnblogs.com/blog/3723410/202602/3723410-20260224190954232-1382162872.png
AOP配置入口点 (XML)

在XML中配置启用Aop标签, 在解析XML自定义标签时, 会拿到 AopNamespaceHandler 命名空间处理器:

public class AopNamespaceHandler extends NamespaceHandlerSupport { @Override public void init() { // In 2.0 XSD as well as in 2.5+ XSDs registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser()); registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser()); registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator()); // Only in 2.0 XSD: moved to context namespace in 2.5+ registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser()); }

复制代码

其内部的注册的 ConfigBeanDefinitionParser 做了两件事

注册一个名称为org.springframework.aop.config.internalAutoProxyCreator 的Bean Definition(对AOP处理);
对应的类, 根据情况有以下三个可能: org.springframework.aop.config.AopConfigUtils#APC_PRIORITY_LIST, 系统会按优先级注册以下三个自动代理创建器之一：
- AnnotationAwareAspectJAutoProxyCreator (最高优先级)
- 当项目中存在AspectJ依赖时启用
- 支持@Aspect注解的切面、@Before、@After等通知注解
- 继承自 AspectJAwareAdvisorAutoProxyCreator
- 能够识别并处理基于注解的切面定义
- AspectJAwareAdvisorAutoProxyCreator (第二优先级)
- 当项目中存在AspectJ依赖但不需要注解支持时启用
- 主要处理XML配置的切面定义
- 继承自 InfrastructureAdvisorAutoProxyCreator
- 提供对AspectJ切点表达式的解析能力
- InfrastructureAdvisorAutoProxyCreator (最低优先级)
- 当项目中不存在AspectJ依赖时启用
- 只处理基础的advisor，不支持切面编程
- 是最基础的自动代理创建器
- 适用于简单的拦截器场景
  注册过程通过AopConfigUtils.registerAutoProxyCreatorIfNecessary方法实现，该方法会根据classpath中是否存在AspectJ相关类来决定注册哪个具体的实现类。

这里对应的是 AspectJAwareAdvisorAutoProxyCreator

解析 aop:config 标签的子元素 (pointcut, advisor, aspect)

每一个通知(Advice) 都会封装为一个 AspectJPointcutAdvisor 的BeanDefinition 将其注册到 BeanFactory
org.springframework.aop.config.ConfigBeanDefinitionParser#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)

@Override @Nullable public BeanDefinition parse(Element element, ParserContext parserContext) { CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element)); parserContext.pushContainingComponent(compositeDef); /** * 1. 注册一个名称为`org.springframework.aop.config.internalAutoProxyCreator` 对AOP处理的Bean Definition; 它是实现 InstantiationAwareBeanPostProcessor 接口的 * 名称是: org.springframework.aop.config.internalAutoProxyCreator * 对应的类, 根据情况有以下三个可能: org.springframework.aop.config.AopConfigUtils#APC_PRIORITY_LIST * InfrastructureAdvisorAutoProxyCreator.class * AspectJAwareAdvisorAutoProxyCreator.class * AnnotationAwareAspectJAutoProxyCreator.class * */ configureAutoProxyCreator(parserContext, element); /** * 2. 解析标签的子元素 (pointcut, advisor, aspect) * 解析 : * 每一个通知(Advice) 都会封装为一个 AspectJPointcutAdvisor 的BeanDefinition 然后将其注册到 BeanFactory * * AspectJPointcutAdvisor 的包含情况 * AspectJPointcutAdvisor 包括: AspectJXXXAdvice(有五种通知) * 而 AspectJXXXAdvice 则包括: 三个关键属性 * 1. java.lang.reflect.Method(通知切面的方法) * 2. org.springframework.aop.aspectj.AspectJExpressionPointcut(切入点表达式) * 3. org.springframework.aop.aspectj.AspectInstanceFactory (切面实例工厂) */ List childElts = DomUtils.getChildElements(element); for (Element elt: childElts) { String localName = parserContext.getDelegate().getLocalName(elt); switch (localName) { /** * 解析 pointcut/切入点 //筛选连接点, 即: 哪些方法需要被代理 */ case POINTCUT -> parsePointcut(elt, parserContext); /** * 解析 advisor/通知/建议/增强处理 //即: 增强功能这一部分代码 */ case ADVISOR -> parseAdvisor(elt, parserContext); /** * 解析 aspect/切面 //切面是**通知(写日志)** 和**切入点(要被代理的方法)** 的结合, 即:**修改后的整个方法, (有正常需要调用的代码,又有写日志的)** * */ case ASPECT -> parseAspect(elt, parserContext); } } parserContext.popAndRegisterContainingComponent(); return null; }

复制代码

二、AOP 代理对象的创建过程

https://img2024.cnblogs.com/blog/3723410/202602/3723410-20260224191037862-476999408.png
AOP 处理入口点 (BPP)

ApplicationContext 在容器创建bean流程中 {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, RootBeanDefinition, Object[])} 会调用接口方法
InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
如果其该返回不为null, 则直接使用这个bean实例返回, 不走正常实例bean流程.
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition)

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // 如果是合成的(mbd是AOP的时候为true) 并且实现 InstantiationAwareBeanPostProcessor 接口 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class targetType = determineTargetType(beanName, mbd); if (targetType != null) { /** * 调用 InstantiationAwareBeanPostProcessor * #postProcessBeforeInstantiation * #postProcessAfterInitialization */ bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; }

复制代码

AspectJAwareAdvisorAutoProxyCreator 创建代理对象

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary

/** * Wrap the given bean if necessary, i.e. if it is eligible for being proxied. * @param bean the raw bean instance * @param beanName the name of the bean * @param cacheKey the cache key for metadata access * @return a proxy wrapping the bean, or the raw bean instance as-is */ protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } /** * 拿到所有匹配织入当前bean的所有通知器(Advisor) * 做了三件事, 见: {@link org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean(java.lang.Class, java.lang.String, org.springframework.aop.TargetSource)} * 1. 往返回 `AspectJXXXAdvice`列表数组`0`索引插入一个{@link org.springframework.aop.interceptor.ExposeInvocationInterceptor} 实例 * 方便传递参数用的 * * 2. 怎么匹配(Advisor)? * Advisor中的 `AspectJExpressionPointcut` 是实现 {@link ClassFilter} 和 {@link org.springframework.aop.MethodMatcher} 接口 * 一个进行类匹配, 一个进行方法匹配. * * 3. 排序, 基于 `有向无环` 图进行排序; 可能匹配到多个切面(aspect) * */ // Create proxy if we have advice. Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { /** *{@link org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#advisedBeans} * 这个变量缓存所有处理过的 bean名称, value 为 boolean值, 如果为false 则不处理 */ this.advisedBeans.put(cacheKey, Boolean.TRUE);//缓存, 表示已处理 /** * 创建代理 * */ Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }

复制代码

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#buildProxy

private Object buildProxy(Class beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource, boolean classOnly) { if (this.beanFactory instanceof ConfigurableListableBeanFactory clbf) { AutoProxyUtils.exposeTargetClass(clbf, beanName, beanClass); } /** * * 1. 创建代理工厂 * {@link org.springframework.aop.framework.ProxyFactory} */ ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); if (proxyFactory.isProxyTargetClass()) { // Explicit handling of JDK proxy targets and lambdas (for introduction advice scenarios) if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) { // Must allow for introductions; can't just set interfaces to the proxy's interfaces only. for (Class ifc : beanClass.getInterfaces()) { proxyFactory.addInterface(ifc); } } } else { // No proxyTargetClass flag enforced, let's apply our default checks... if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } else { // 尝试获取所有接口 evaluateProxyInterfaces(beanClass, proxyFactory); } } /** * 所有匹配的 Advisor */ Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); proxyFactory.addAdvisors(advisors); /** * 被代理的对象 */ proxyFactory.setTargetSource(targetSource); /** * 2.定制化 ProxyFactory (预留扩展的) */ customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } // Use original ClassLoader if bean class not locally loaded in overriding class loader ClassLoader classLoader = getProxyClassLoader(); if (classLoader instanceof SmartClassLoader smartClassLoader && classLoader != beanClass.getClassLoader()) { classLoader = smartClassLoader.getOriginalClassLoader(); } /** * 3.根据 classOnly 决定返回的是: 代理对象的class, 还是代理对象的实例 */ return (classOnly ? proxyFactory.getProxyClass(classLoader) : proxyFactory.getProxy(classLoader)); }

复制代码

AOP 的两种织入原理

1.静态AOP (AspectJ)

静态AOP：在编译期，切面直接以字节码的形式编译到目标字节码文件中。
AspectJ 属于静态AOP，是在编译时进行增强，会在编译的时候将AOP逻辑织入到代码中，需要专有的编译器和织入器。
优点：被织入的类性能不受影响。
缺点：不够灵活
javassist
[[Java 字节码指令]]
2.动态AOP

JDK 动态代理

[[10.结构型 - 代理模式 (Proxy Pattern)]]
在正常开发中, 基于依赖倒置原则（Dependence Inversion Principle）, 通常需要接口解决上层与类的耦合问题;
即A类调用B类, 为了解决A依赖与B, 抽取B做成C接口. 变成A依赖以C接口;
在运行期，目标类加载后，为接口动态生成代理类，将切面植入到代理类中。
Java从1.3引入动态代理。实现原理是为被代理的业务接口生成代理类，将AOP逻辑写入到代理类中，在运行时动态织入AOP，使用反射执行织入的逻辑。
主要实现方式依赖 java.lang.reflect 包下的InvocationHandler和Proxy类。
优点：Java标准库原生支持，使用简单，无需引用额外的包。相对于静态AOP更灵活。
缺点：带代理的类必须是接口，灵活性受到一些限制；使用反射会影响一些性能。
JDK 动态代理必须需要接口, 它的原理是动态的生成class, 类似实现原始类的接口

/** * JDK 动态代理实现 */public static final void JDK_PROXY(){ /** * 目标类 */ ProductServiceInter carService = new CarService(); // 拦截回调处理器 InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result ; System.out.println("增强处理前"); //调用方法 result = method.invoke(carService, args); System.out.println("增强处理后"); return result; } }; ProductServiceInter proxyInstance = (ProductServiceInter) Proxy.newProxyInstance(CarService.class.getClassLoader() , CarService.class.getInterfaces(), handler); proxyInstance.doProduct("白色");}

复制代码

CGLIB 动态代理

CGLIB(Code Generation Library)是一个开源项目,是一个强大的, 高性能, 高质量的Code生成类库, 它可以在运行期扩展Java类与实现Java接口, 其实就是cglib可以在运行时动态生成字节码;
使用CGLib实现动态代理, 完全不受代理类必须实现接口的限制, 而且CGLib底层采用ASM字节码生成框架, 使用字节码技术生成代理类, 比使用Java反射效率要高; 唯一需要注意的是, CGLib不能对声明为final的方法进行代理, 因为CGLib原理是动态生成被代理类的子类;
它的原理是: 动态的创建一份class(代理类) 继承/实现被代理的类/接口

net.sf.cglib.proxy.Enhancer – 主要的增强类
net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类
它是Callback接口的子接口, 需要用户实现
net.sf.cglib.proxy.MethodProxyJDK的java.lang.reflect.Method类的代理类
可以方便的实现对源对象方法的调用,如使用: Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象, 也不会出现死循环的问题;
net.sf.cglib.proxy.MethodInterceptor 接口是最通用的回调（callback）类型
它经常被基于代理的AOP用来实现拦截（intercept）方法的调用; 这个接口只定义了一个方法,public Object intercept(Object object, java.lang.reflect.Method method,Object[] args, MethodProxy proxy) throws Throwable;
第一个参数是代理对像, 第二和第三个参数分别是拦截的方法和方法的参数; 原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用, 或者使用 net.sf.cglib.proxy.MethodProxy对象调用;
sf.cglib.proxy.MethodProxy通常被首选使用, 因为它更快;
一个动态代理例子

/** * CGLIB 动态代理实现 */public static final void CJLIB_PROXY(){ Enhancer enhancer = new Enhancer(); /** * 设置父类 */ enhancer.setSuperclass(CarService.class); // 拦截回调处理器 MethodInterceptor handler = new MethodInterceptor() { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { Object result ; System.out.println("增强处理前"); //调用父对象方法 result = proxy.invokeSuper(obj, args); System.out.println("增强处理后"); return result; } }; // 设置拦截回调处理器; 它可以是: * @see MethodInterceptor * @see NoOp * @see LazyLoader * @see Dispatcher * @see org.springframework.cglib.proxy.InvocationHandler * @see FixedValue enhancer.setCallback(handler); CarService proxyInstance = (CarService) enhancer.create(); proxyInstance.doProduct("粉色");}

复制代码

三、AOP 代理对象的方法调用过程

https://img2024.cnblogs.com/blog/3723410/202602/3723410-20260224191135364-2132190076.png
源码调试主入口

主入口构成一个责任链的形式
org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept

@Override @Nullable public Object proceed() throws Throwable { /** * 这里循环责任链的调用 */ // We start with an index of -1 and increment early. if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { return invokeJoinpoint(); } /** * 这个`this.interceptorsAndDynamicMethodMatchers` 数组就是通知(advised)列表 AspectJXXXAdvice (这里再封装为 XXXAdviceInterceptor) * 第0个是此前插入的 `ExposeInvocationInterceptor` 它哈都没干, 直接 proceed(); 回调回来; * * 这里累加 ++this.currentInterceptorIndex, 每次回调回来, 拿到下一个 `XXXAdviceInterceptor` 调用 */ Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher dm) { // Evaluate dynamic method matcher here: static part will already have // been evaluated and found to match. Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass()); if (dm.matcher().matches(this.method, targetClass, this.arguments)) { return dm.interceptor().invoke(this); } else { // Dynamic matching failed. // Skip this interceptor and invoke the next in the chain. return proceed(); } } else { /** * 将 `this` 传递进去, 各 XXXAdviceInterceptor 将使用这个参数, 回调回来 */ // It's an interceptor, so we just invoke it: The pointcut will have // been evaluated statically before this object was constructed. return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } }

复制代码

Around 通知

org.springframework.aop.aspectj.AspectJAroundAdvice#invoke

@Override@Nullablepublic Object invoke(MethodInvocation mi) throws Throwable { if (!(mi instanceof ProxyMethodInvocation pmi)) { throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi); } /** * 封装一个 ProceedingJoinPoint 参数, 这个就是给环绕通知方法接受的参数 */ ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi); JoinPointMatch jpm = getJoinPointMatch(pmi); // 环绕通知内部, 调用 `joinPoint.proceed();` 其实还是会回去责任链那里的, 并不是真正的调用原始方法 return invokeAdviceMethod(pjp, jpm, null, null);}

复制代码

After 通知

没啥重点
org.springframework.aop.aspectj.AspectJAfterReturningAdvice#afterReturning

@Override public void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable { if (shouldInvokeOnReturnValueOf(method, returnValue)) { invokeAdviceMethod(getJoinPointMatch(), returnValue, null); } }

复制代码

Throwing 通知

org.springframework.aop.aspectj.AspectJAfterThrowingAdvice#invoke

@Override @Nullable public Object invoke(MethodInvocation mi) throws Throwable { try { return mi.proceed(); } catch (Throwable ex) { if (shouldInvokeOnThrowing(ex)) { invokeAdviceMethod(getJoinPointMatch(), null, ex); } throw ex; } }

复制代码

四、Spring AOP 的使用

一个案例

An AOP Example - https://docs.spring.io/spring-framework/reference/core/aop/ataspectj/example.html

例有一个 ProductServiceInter 接口

public interface ProductServiceInter { void doProduct(String color); }

复制代码

有两个实现

public class CarService implements ProductServiceInter { public void doProduct(String color){ System.out.println("生产一辆 " + color + " 颜色的汽车"); } }

复制代码

public class BicycleService implements ProductServiceInter { public void doProduct(String color){ System.out.println("生产一辆 " + color + " 颜色的自行车"); } }

复制代码

业务需求

调用 BicycleService#doProduct 方法前, 需要记录日志
调用 CarService#doProduct 方法前, 同样也需要记录日志

解决方式(过程式)

ProductServiceInter carService = new CarService();ProductServiceInter bicycleService = new BicycleService();//....写日志carService.doProduct("红色"); //....写日志bicycleService.doProduct("黑色");

复制代码

问题

有几点不合理的地方:

写日志部分代码重复
大量的 service 都有此需要,又有少量的 service 没这个需要, 不好修改

AOP 概念术语

AOP Concepts - https://docs.spring.io/spring-framework/reference/core/aop/introduction-defn.html

Advice
/通知/建议/增强处理/... //即: 增强功能这一部分代码
joinpoint
/连接点 //和方法有关的前前后后（抛出异常）, 都是连接点;
Pointcut
/切入点 //筛选连接点, 即: 哪些方法需要被代理
Aspect
/切面 //切面是通知(写日志) 和切入点(要被代理的方法) 的结合, 即:修改后的整个方法 //(有正常需要调用的(doProduct)代码,又有写日志的)
target
/目标/目标对象 //即: Service 它们都没有写日志的功能
weaving
/织入 //把切面应用到目标对象来创建新的代理对象的过程;
AOP代理类
/AOP修改后的类

基于XML 的配置方式

Schema-based AOP Support

public class AdviceService { public void before(){ System.out.println("前置通知（Before),它在执行方法之前调用"); } public void after(){ System.out.println("后置通知（After returning advice）,它在执行匹配pointcut的方法之后调用"); } public void after_throwing(Exception ex){ System.out.println("异常通知（After throwing advice）,它在执行匹配pointcut的方法时出现异常调用"); System.out.println("异常信息:"+ ex.getMessage() ); } public Object around(ProceedingJoinPoint mi){ System.out.println("环绕通知（Around advice）之前"); Object result = null; try { result = mi.proceed(); } catch (Throwable e) { e.printStackTrace(); } System.out.println("环绕通知（Around advice）之后"); return result; }}

复制代码

public static void main(String[] args) { System.out.println("=========================================================="); System.out.println(""); ApplicationContext context = new ClassPathXmlApplicationContext("application-aop.xml"); /** * 如果目标bean有接口的话, 会使用JDK动态代理实现; * 获取的也是接口 (ProductServiceInter) */ ProductServiceInter carService = (ProductServiceInter) context.getBean("carService"); carService.doProduct("五颜六色"); System.out.println(""); System.out.println("==========================================================");}

复制代码

表达式 (execution)

使用 execution 表达式, 需要引入aop项目的 optional("org.aspectj:aspectjweaver") 依赖
execution 表达式的格式, 括号中各个pattern分别表示:
修饰符匹配（modifier-pattern?）
返回值匹配（ret-type-pattern）
类路径匹配（declaring-type-pattern?）
方法名匹配（name-pattern）
参数匹配 (param-pattern)
异常类型匹配（throws-pattern?）
其中后面跟着"?"的是可选项定义时, 还可以使用&&, ||, !
其他通知 (Advice)

spring有如下几种 Advice (通知)

前置通知（Before advice）
在某连接点之前执行的通知.
https://docs.spring.io/spring-framework/reference/core/aop/schema.html#aop-schema-advice-before
后置通知（After returning advice）
在某连接点正常完成后执行的通知.
https://docs.spring.io/spring-framework/reference/core/aop/schema.html#aop-schema-advice-after-returning
异常通知（After throwing advice）:
在方法抛出异常退出时执行的通知;
最终通知（After (finally) advice）:
当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）;
环绕通知（Around Advice）:
包围一个连接点的通知, 如方法调用; 这是最强大的一种通知类型; 环绕通知可以在方法调用前后完成自定义的行为; 它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行;

复制代码

基于注解的配置方式

@AspectJ support - https://docs.spring.io/spring-framework/reference/core/aop/ataspectj.html
启用注解支持

@Configuration@EnableAspectJAutoProxypublic class AppConfig {}

复制代码

配置切面 Aspect

@Aspect@Componentpublic class MyAdvice {}

复制代码

配置切点 Pointcut

@Aspect@Componentpublic class MyAdvice { /** * 定义 pointcut (切入点) */ // @Pointcut("@annotation(net.jk.cloud.log.aop.log.Log)") //按照注解的方式, 只要在方法上加`net.jk.cloud.log.aop.log.Log`注解, 即会被织入 @Pointcut("execution(* com.yang.service.Test*_Service.*(..))")//按照表达式 public void logPointcut() { // 该方法无方法体,主要为了使用此切入点 } /** @Around("logPointcut()") 环绕通知使用 logPointcut() 切点; 相当于XML的例如相对应的异常通知 @AfterThrowing(pointcut = "logPointcut()", throwing = "e") =

复制代码

配置通知 Advice

@Aspect@Componentpublic class MyAdvice { /** * 定义 pointcut (切入点) */ // @Pointcut("@annotation(net.jk.cloud.log.aop.log.Log)") //按照注解的方式, 只要在方法上加`net.jk.cloud.log.aop.log.Log`注解, 即会被织入 @Pointcut("execution(* com.yang.service.Test*_Service.*(..))")//按照表达式 public void logPointcut() { // 该方法无方法体,主要为了使用此切入点 } /** @Around("logPointcut()") 环绕通知使用 logPointcut() 切点; 相当于XML的例如, 相对应的异常通知 @AfterThrowing(pointcut = "logPointcut()", throwing = "e") =

复制代码

踩坑指南

spring boot 项目使用了AOP代理的Bean CglibAopProxy 方法是存在缓存的, 注意缓存注意缓存注意缓存!
另外:
Spring 通过CGLIB 创建的代理类, 不会初始化代理类自身继承的任何成员变量, 包括final类型的成员变量!
正确使用AOP 需要避坑:

访问被注入的 Bean 时, 总是调用方法而非直接访问字段;
编写Bean时, 如果可能会被代理, 就不要编写 public final方法;

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

向梦桐 · 昨天 07:15

前排留名，哈哈哈

指陡 · 昨天 11:05

东西不错很实用谢谢分享

账号		自动登录	找回密码
密码			立即注册

一文学习 Spring AOP 源码全过程

相关帖子

回复

签约作者

一文学习 Spring AOP 源码全过程

相关帖子

相关推荐

回复

签约作者