嗨,你好呀,我是猿java
Spring AOP是 Spring框架中的一个重要模块,它通过分离关注点来提高代码的模块化程度,AOP允许开发者在不改变业务逻辑的情况下,通过切面来增强或修改代码的行为。本文我们将深入分析 Spring AOP的原理。
Spring AOP概述 {#Spring-AOP概述}
什么是AOP? {#什么是AOP?}
AOP,全程 Aspect-Oriented Programming,中文翻译为面向切面编程,它是一种编程范式,旨在通过将横切关注点(如日志记录、事务管理、权限控制等)分离出来,使得这些关注点可以独立于业务逻辑进行处理。AOP的核心概念包括:
- 切面(Aspect):模块化的关注点,通常横切多个对象。
- 连接点(Join Point):程序执行过程中的某个点,比如方法调用或异常抛出。
- 通知(Advice):在切面的某个特定的连接点上执行的动作。
- 切入点(Pointcut):匹配连接点的断言。
- 目标对象(Target Object):被通知的对象。
- 代理(Proxy):通知目标对象后,创建的对象。
- 织入(Weaving):将切面连接到其它应用程序类型或对象上,并创建一个通知对象。
Spring AOP的核心原理 {#Spring-AOP的核心原理}
AOP的实现机制 {#AOP的实现机制}
Spring AOP基于代理模式实现,主要通过Proxy
对象来替代目标对象,并在Proxy
对象的方法调用中插入切面逻辑。Spring AOP使用ProxyFactory
和AdvisedSupport
等类来管理和创建代理对象。代理又可以细分为:
- JDK动态代理:基于接口的代理,目标对象必须实现一个或多个接口。
- CGLIB代理:基于子类的代理,适用于目标对象没有实现接口的情况。
AOP的核心组件 {#AOP的核心组件}
- Advisor:包含切入点和通知的元数据。
- Advice:定义切面在连接点上执行的操作。
- Pointcut:定义匹配连接点的规则。
- AopProxy :负责创建代理实例,具体实现有
JdkDynamicAopProxy
和CglibAopProxy
。
AOP的执行流程 {#AOP的执行流程}
Spring AOP的执行流程是理解其工作原理的关键,它通过在程序运行时动态地将切面逻辑织入到目标对象中,从而实现横切关注点的分离。下面我们来详细地分析 Spring AOP的执行流程。
配置切面 {#配置切面}
AOP的执行流程从配置切面开始,切面可以通过 XML配置文件或基于注解的方式进行定义。配置切面时,主要涉及以下几个元素:
- 切面类(Aspect) :包含横切逻辑的类,通常用
@Aspect
注解标识。 - 通知方法(Advice) :定义在特定连接点上执行的横切逻辑。通知类型包括
@Before
、@After
、@Around
、@AfterReturning
、@AfterThrowing
等。 - 切入点表达式(Pointcut Expression):用于匹配连接点的方法执行点,通常使用AspectJ的切入点表达式语法。
创建代理对象 {#创建代理对象}
在Spring容器启动时,Spring会扫描配置的切面类,并为每个目标对象创建代理对象。代理对象负责在目标方法执行前后插入切面逻辑。Spring AOP使用两种主要的代理方式:
- JDK动态代理:适用于目标对象实现了接口的情况,通过Java的反射机制创建代理对象。
- CGLIB代理:适用于目标对象没有实现接口的情况,通过生成目标类的子类来创建代理。
方法调用拦截 {#方法调用拦截}
当客户端代码调用目标对象的方法时,实际上是通过代理对象来进行调用的。代理对象实现了与目标对象相同的接口,因此客户端代码无需感知代理的存在。
- 拦截方法调用 :代理对象拦截对目标方法的调用。对于JDK动态代理,这是通过实现
InvocationHandler
接口的invoke
方法来实现的;对于CGLIB代理,这是通过生成子类并重写方法来实现的。
执行通知 {#执行通知}
在方法调用被拦截后,代理对象会根据切面配置执行相应的通知逻辑:
- Before通知:在目标方法执行之前执行。
- After通知:在目标方法执行之后执行,无论方法是否抛出异常。
- Around通知:包围目标方法的执行,可以在方法执行前后进行自定义逻辑,甚至可以决定是否执行目标方法。
- AfterReturning通知:在目标方法成功返回后执行。
- AfterThrowing通知:在目标方法抛出异常后执行。
执行目标方法 {#执行目标方法}
在执行完Before
或Around
通知的前置逻辑后,代理对象会调用目标对象的实际方法。目标方法执行完成后,代理对象会继续执行After
、Around
的后置逻辑、AfterReturning
或AfterThrowing
通知。
返回结果或抛出异常 {#返回结果或抛出异常}
代理对象在完成所有通知逻辑后,将目标方法的返回结果返回给调用方。如果目标方法抛出异常,代理对象也会处理异常并根据配置决定是否重新抛出或转换异常。
结束 {#结束}
AOP的执行流程在代理对象返回结果或抛出异常后结束,整个过程是透明的,调用方无需关心代理的存在,目标对象的行为在运行时被增强。
Spring AOP核心源码分析 {#Spring-AOP核心源码分析}
Spring AOP的源码涉及到多个核心类和接口,包括ProxyFactory
、AdvisedSupport
、AopProxy
、JdkDynamicAopProxy
、CglibAopProxy
等。下面,我们将对这些核心组件进行详细分析。
ProxyFactory {#ProxyFactory}
ProxyFactory
是Spring AOP创建代理的核心工厂类。它负责根据配置创建合适的代理对象(JDK动态代理或CGLIB代理)。
|---------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| public class ProxyFactory extends ProxyCreatorSupport { // 获取代理对象 public Object getProxy() { return createAopProxy().getProxy(); } // 创建AopProxy对象 protected AopProxy createAopProxy() { if (!this.isProxyTargetClass()) { // 是否强制使用CGLIB代理 return new JdkDynamicAopProxy(this); } return new CglibAopProxy(this); } }
|
getProxy()
:对外提供获取代理对象的方法。createAopProxy()
:根据ProxyTargetClass
属性判断使用JDK动态代理还是CGLIB代理。
AdvisedSupport {#AdvisedSupport}
AdvisedSupport
是Spring AOP的配置类,持有AOP代理需要的各种配置,包括目标对象、切面、通知等。
|-------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8
| public class AdvisedSupport extends ProxyConfig implements Advised { private TargetSource targetSource; private List<Advisor> advisors = new ArrayList<>(); private List<Class<?>> interfaces = new ArrayList<>(); // 其他配置和方法 }
|
TargetSource
:封装了目标对象。advisors
:存储应用于目标对象的通知(Advice)和切入点(Pointcut)。interfaces
:代理对象需要实现的接口列表。
AopProxy接口 {#AopProxy接口}
AopProxy
是一个接口,定义了AOP代理对象的创建方法。
|-----------------|----------------------------------------------------------------------------------------------------|
| 1 2 3 4
| public interface AopProxy { Object getProxy(); Object getProxy(ClassLoader classLoader); }
|
getProxy()
:用于创建代理对象。getProxy(ClassLoader classLoader)
:允许指定类加载器创建代理对象。
JdkDynamicAopProxy {#JdkDynamicAopProxy}
JdkDynamicAopProxy
实现了AopProxy
接口,使用JDK动态代理为目标对象创建代理。
|------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
| public class JdkDynamicAopProxy implements AopProxy, InvocationHandler { private final AdvisedSupport advised; public JdkDynamicAopProxy(AdvisedSupport config) { this.advised = config; } @Override public Object getProxy() { return getProxy(Thread.currentThread().getContextClassLoader()); } @Override public Object getProxy(ClassLoader classLoader) { return Proxy.newProxyInstance(classLoader, this.advised.getProxiedInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, this.advised.getTargetClass()); if (chain.isEmpty()) { return method.invoke(this.advised.getTargetSource().getTarget(), args); } MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, this.advised.getTargetSource().getTarget(), method, args, chain); return invocation.proceed(); } }
|
getProxy()
:通过Proxy.newProxyInstance
创建代理对象。invoke()
:实现InvocationHandler
接口的方法,负责方法调用的拦截和通知链的执行。
CglibAopProxy {#CglibAopProxy}
CglibAopProxy
同样实现了AopProxy
接口,使用CGLIB库为目标对象创建代理。
|---------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
| public class CglibAopProxy implements AopProxy { private final AdvisedSupport advised; public CglibAopProxy(AdvisedSupport config) { this.advised = config; } @Override public Object getProxy() { return getProxy(Thread.currentThread().getContextClassLoader()); } @Override public Object getProxy(ClassLoader classLoader) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(this.advised.getTargetClass()); enhancer.setInterfaces(this.advised.getProxiedInterfaces()); enhancer.setCallback(new DynamicAdvisedInterceptor(this.advised)); return enhancer.create(); } private static class DynamicAdvisedInterceptor implements MethodInterceptor { private final AdvisedSupport advised; public DynamicAdvisedInterceptor(AdvisedSupport advised) { this.advised = advised; } @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, this.advised.getTargetClass()); if (chain.isEmpty()) { return proxy.invokeSuper(obj, args); } MethodInvocation invocation = new CglibMethodInvocation(obj, this.advised.getTargetSource().getTarget(), method, args, proxy, chain); return invocation.proceed(); } } }
|
getProxy()
:使用CGLIB的Enhancer
创建代理对象。DynamicAdvisedInterceptor
:CGLIB的拦截器实现,负责方法调用的拦截和通知链的执行。
MethodInvocation {#MethodInvocation}
MethodInvocation
接口及其实现类(如ReflectiveMethodInvocation
)负责封装方法调用的上下文信息,并管理通知链的执行。
|---------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| public interface MethodInvocation extends Joinpoint { Method getMethod(); Object[] getArguments(); } public class ReflectiveMethodInvocation implements MethodInvocation { private final Object proxy; private final Object target; private final Method method; private final Object[] arguments; private final List<?> interceptorsAndDynamicMethodMatchers; private int currentInterceptorIndex = -1; @Override public Object proceed() throws Throwable { if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { return this.method.invoke(this.target, this.arguments); } Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); if (interceptorOrInterceptionAdvice instanceof MethodInterceptor) { MethodInterceptor interceptor = (MethodInterceptor) interceptorOrInterceptionAdvice; return interceptor.invoke(this); } else { return proceed(); } } }
|
proceed()
:递归调用通知链中的下一个拦截器,最终执行目标方法。
通过对 Spring AOP源码的详细分析,我们可以看到Spring AOP是如何通过代理模式实现面向切面编程的。
Spring AOP应用示例 {#Spring-AOP应用示例}
下面我们通过一个简单的 Spring AOP示例,展示如何通过AOP实现日志记录。
定义业务类 {#定义业务类}
|-------------------|------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5
| public class UserService { public void createUser(String username) { System.out.println("Creating user: " + username); } }
|
定义切面 {#定义切面}
|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8
| @Aspect public class LoggingAspect { @Before("execution(* UserService.createUser(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("Before method: " + joinPoint.getSignature().getName()); } }
|
Spring配置 {#Spring配置}
使用Java配置:
|------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14
| @Configuration @EnableAspectJAutoProxy public class AppConfig { @Bean public UserService userService() { return new UserService(); } @Bean public LoggingAspect loggingAspect() { return new LoggingAspect(); } }
|
测试AOP功能 {#测试AOP功能}
|-----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7
| public class AopTest { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); UserService userService = context.getBean(UserService.class); userService.createUser("Alice"); } }
|
输出结果:
|-------------|--------------------------------------------------------|
| 1 2
| Before method: createUser Creating user: Alice
|
总结 {#总结}
Spring AOP通过代理模式实现了面向切面编程,能够在不改变业务逻辑的情况下增强代码功能。通过本文的分析,我们了解了 Spring AOP的基本概念、实现机制、核心组件以及如何在实际项目中应用 AOP。Spring AOP的强大之处在于其灵活性和可扩展性,使得开发者可以轻松地实现横切关注点的分离和复用。
交流学习 {#交流学习}
最后,把猿哥的座右铭送给你:投资自己才是最大的财富。 如果你觉得文章有帮助,请帮忙转发给更多的好友,或关注公众号:猿java,持续输出硬核文章。