关于 Spring AOP 的原理分析!

开发 后端
通过本文的分析,我们将了解了 Spring AOP的基本概念、实现机制、核心组件以及如何在实际项目中应用 AOP。

Spring AOP是 Spring框架中的一个重要模块,它通过分离关注点来提高代码的模块化程度,AOP允许开发者在不改变业务逻辑的情况下,通过切面来增强或修改代码的行为。本文我们将深入分析 Spring AOP的原理。

一、Spring AOP概述

什么是AOP?

AOP,全程 Aspect-Oriented Programming,中文翻译为面向切面编程,它是一种编程范式,旨在通过将横切关注点(如日志记录、事务管理、权限控制等)分离出来,使得这些关注点可以独立于业务逻辑进行处理。AOP的核心概念包括:

  • 切面(Aspect):模块化的关注点,通常横切多个对象。
  • 连接点(Join Point):程序执行过程中的某个点,比如方法调用或异常抛出。
  • 通知(Advice):在切面的某个特定的连接点上执行的动作。
  • 切入点(Pointcut):匹配连接点的断言。
  • 目标对象(Target Object):被通知的对象。
  • 代理(Proxy):通知目标对象后,创建的对象。
  • 织入(Weaving):将切面连接到其它应用程序类型或对象上,并创建一个通知对象。

二、Spring AOP的核心原理

1.AOP的实现机制

Spring AOP基于代理模式实现,主要通过Proxy对象来替代目标对象,并在Proxy对象的方法调用中插入切面逻辑。Spring AOP使用ProxyFactory和AdvisedSupport等类来管理和创建代理对象。代理又可以细分为:

  • JDK动态代理:基于接口的代理,目标对象必须实现一个或多个接口。
  • CGLIB代理:基于子类的代理,适用于目标对象没有实现接口的情况。

2.AOP的核心组件

  • Advisor:包含切入点和通知的元数据。
  • Advice:定义切面在连接点上执行的操作。
  • Pointcut:定义匹配连接点的规则。
  • AopProxy:负责创建代理实例,具体实现有JdkDynamicAopProxy和CglibAopProxy。

3.AOP的执行流程

Spring AOP的执行流程是理解其工作原理的关键,它通过在程序运行时动态地将切面逻辑织入到目标对象中,从而实现横切关注点的分离。下面我们来详细地分析 Spring AOP的执行流程。

(1) 配置切面

AOP的执行流程从配置切面开始,切面可以通过 XML配置文件或基于注解的方式进行定义。配置切面时,主要涉及以下几个元素:

  • 切面类(Aspect):包含横切逻辑的类,通常用@Aspect注解标识。
  • 通知方法(Advice):定义在特定连接点上执行的横切逻辑。通知类型包括@Before、@After、@Around、@AfterReturning、@AfterThrowing等。
  • 切入点表达式(Pointcut Expression):用于匹配连接点的方法执行点,通常使用AspectJ的切入点表达式语法。

(2) 创建代理对象

在Spring容器启动时,Spring会扫描配置的切面类,并为每个目标对象创建代理对象。代理对象负责在目标方法执行前后插入切面逻辑。Spring AOP使用两种主要的代理方式:

  • JDK动态代理:适用于目标对象实现了接口的情况,通过Java的反射机制创建代理对象。
  • CGLIB代理:适用于目标对象没有实现接口的情况,通过生成目标类的子类来创建代理。

(3) 方法调用拦截

当客户端代码调用目标对象的方法时,实际上是通过代理对象来进行调用的。代理对象实现了与目标对象相同的接口,因此客户端代码无需感知代理的存在。

  • 拦截方法调用:代理对象拦截对目标方法的调用。对于JDK动态代理,这是通过实现InvocationHandler接口的invoke方法来实现的;对于CGLIB代理,这是通过生成子类并重写方法来实现的。

(4) 执行通知

在方法调用被拦截后,代理对象会根据切面配置执行相应的通知逻辑:

  • Before通知:在目标方法执行之前执行。
  • After通知:在目标方法执行之后执行,无论方法是否抛出异常。
  • Around通知:包围目标方法的执行,可以在方法执行前后进行自定义逻辑,甚至可以决定是否执行目标方法。
  • AfterReturning通知:在目标方法成功返回后执行。
  • AfterThrowing通知:在目标方法抛出异常后执行。

(5) 执行目标方法

在执行完Before或Around通知的前置逻辑后,代理对象会调用目标对象的实际方法。目标方法执行完成后,代理对象会继续执行After、Around的后置逻辑、AfterReturning或AfterThrowing通知。

(6) 返回结果或抛出异常

代理对象在完成所有通知逻辑后,将目标方法的返回结果返回给调用方。如果目标方法抛出异常,代理对象也会处理异常并根据配置决定是否重新抛出或转换异常。

(7) 结束

AOP的执行流程在代理对象返回结果或抛出异常后结束,整个过程是透明的,调用方无需关心代理的存在,目标对象的行为在运行时被增强。

三、Spring AOP核心源码分析

Spring AOP的源码涉及到多个核心类和接口,包括ProxyFactory、AdvisedSupport、AopProxy、JdkDynamicAopProxy、CglibAopProxy等。下面,我们将对这些核心组件进行详细分析。

1.ProxyFactory

ProxyFactory是Spring AOP创建代理的核心工厂类。它负责根据配置创建合适的代理对象(JDK动态代理或CGLIB代理)。

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代理。

2.AdvisedSupport

AdvisedSupport是Spring AOP的配置类,持有AOP代理需要的各种配置,包括目标对象、切面、通知等。

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:代理对象需要实现的接口列表。

3.AopProxy接口

AopProxy是一个接口,定义了AOP代理对象的创建方法。

public interface AopProxy {
    Object getProxy();
    Object getProxy(ClassLoader classLoader);
}
  • getProxy():用于创建代理对象。
  • getProxy(ClassLoader classLoader):允许指定类加载器创建代理对象。

4.JdkDynamicAopProxy

JdkDynamicAopProxy实现了AopProxy接口,使用JDK动态代理为目标对象创建代理。

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接口的方法,负责方法调用的拦截和通知链的执行。

5.CglibAopProxy

CglibAopProxy同样实现了AopProxy接口,使用CGLIB库为目标对象创建代理。

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的拦截器实现,负责方法调用的拦截和通知链的执行。

6.MethodInvocation

MethodInvocation接口及其实现类(如ReflectiveMethodInvocation)负责封装方法调用的上下文信息,并管理通知链的执行。

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示例,展示如何通过AOP实现日志记录。

1.定义业务类

public class UserService {
    public void createUser(String username) {
        System.out.println("Creating user: " + username);
    }
}

2.定义切面

@Aspect
public class LoggingAspect {

    @Before("execution(* UserService.createUser(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }
}

3.Spring配置

使用Java配置:

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService();
    }

    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

4.测试AOP功能

public class AopTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        userService.createUser("Alice");
    }
}

输出结果:

Before method: createUser
Creating user: Alice

五、总结

Spring AOP通过代理模式实现了面向切面编程,能够在不改变业务逻辑的情况下增强代码功能。通过本文的分析,我们了解了 Spring AOP的基本概念、实现机制、核心组件以及如何在实际项目中应用 AOP。Spring AOP的强大之处在于其灵活性和可扩展性,使得开发者可以轻松地实现横切关注点的分离和复用。

责任编辑:赵宁宁 来源: 猿java
相关推荐

2021-05-06 18:17:52

SpringAOP理解

2012-09-27 09:47:43

SpringJava面向对象

2011-09-15 10:15:30

Spring

2018-10-25 16:20:23

JavaSpring AOPSpringMVC

2012-09-28 10:20:14

IBMdw

2022-05-26 09:03:39

AOP编程

2009-06-19 13:28:30

Spring AOPSpring 2.0

2022-06-07 07:58:45

SpringSpring AOP

2022-02-17 13:39:09

AOP接口方式

2009-06-22 10:41:34

Spring.AOP

2009-06-18 14:54:52

Spring AOP

2019-11-29 16:21:22

Spring框架集成

2023-03-31 08:22:48

javassitcglibAOP

2022-06-08 08:04:28

Springservicerepository

2009-09-29 10:00:40

Spring AOP框

2009-06-19 11:09:27

Spring AOP

2022-07-01 09:39:58

SpringAOPIOC

2011-04-26 09:33:04

SpringAOP

2012-07-11 14:31:16

SpringAop

2023-05-04 00:06:40

点赞
收藏

51CTO技术栈公众号