Spring AOP – 顶峰相见

文章目录 隐藏

1 1. Spring AOP 的基本概念

2 2. Spring AOP 的底层实现：JDK 动态代理和 CGLIB

5 5. Spring AOP 如何选择代理方式

6 6. Spring AOP 的执行流程

7 7. 总结

Spring AOP（Aspect-Oriented Programming） 是 Spring 框架中用于面向切面编程的功能模块，它允许开发者在不修改原始代码的情况下增强类的功能。Spring AOP 在底层实现上，主要通过 JDK 动态代理 和 CGLIB 来生成代理对象，并在方法调用前后执行增强逻辑。下面是对 Spring AOP 原理的深入分析。

1. Spring AOP 的基本概念

在 Spring AOP 中，几个核心概念包括：

切面（Aspect）：包含增强逻辑的模块，封装了横切关注点（如事务管理、日志记录等）。
通知（Advice）：切面中定义的增强逻辑，分为前置通知、后置通知、异常通知、返回通知和环绕通知。
切点（Pointcut）：定义在哪些方法或位置应用增强逻辑。
连接点（Join Point）：程序执行时可以插入增强逻辑的位置，Spring AOP 支持方法级别的连接点。
目标对象（Target Object）：被代理的原始对象。
代理对象（Proxy）：增强后的目标对象，包含了原始方法和增强逻辑。

2. Spring AOP 的底层实现：JDK 动态代理和 CGLIB

Spring AOP 的核心是通过 代理模式 来实现的。Spring AOP 在运行时根据不同条件选择代理方式，以便在方法调用前后插入增强逻辑：

JDK 动态代理：用于代理实现了接口的类。基于 java.lang.reflect.Proxy 生成代理类。
CGLIB 动态代理：用于代理没有实现接口的类。CGLIB 是一个基于 ASM 字节码操作的第三方库，通过创建目标类的子类来实现代理。

代理选择策略

当目标类实现了接口时，Spring 默认使用 JDK 动态代理。
当目标类没有实现任何接口时，Spring 使用 CGLIB 动态代理。
可以通过配置强制使用 CGLIB（如在 @EnableAspectJAutoProxy(proxyTargetClass = true) 中指定 proxyTargetClass = true）。

3. JDK 动态代理实现原理

JDK 动态代理是 Java 自带的一种动态代理机制，代理类在运行时生成。它依赖接口定义，即目标类必须实现接口。JDK 动态代理的主要步骤如下：

接口定义：JDK 动态代理要求目标类实现一个或多个接口。代理类会实现与目标类相同的接口。
代理类生成：使用 Proxy.newProxyInstance() 创建代理对象。此方法接收三个参数：类加载器、接口列表和 InvocationHandler 实例。
调用处理：当代理对象调用方法时，调用会被 InvocationHandler 的 invoke 方法拦截，并在 invoke 中执行增强逻辑和目标方法。

示例代码：

javaCopy codeimport java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkProxyExample {

    interface Service {
        void perform();
    }

    static class ServiceImpl implements Service {
        public void perform() {
            System.out.println("Executing Service logic");
        }
    }

    static class ServiceInvocationHandler implements InvocationHandler {
        private final Service target;

        public ServiceInvocationHandler(Service target) {
            this.target = target;
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before executing method");
            Object result = method.invoke(target, args); // 调用目标方法
            System.out.println("After executing method");
            return result;
        }
    }

    public static void main(String[] args) {
        Service target = new ServiceImpl();
        Service proxy = (Service) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new ServiceInvocationHandler(target)
        );

        proxy.perform();
    }
}

优点：

使用接口代理，轻量且简单。
运行时生成代理类，无需提前生成字节码。

缺点：

只能代理实现了接口的类。
InvocationHandler 使用反射调用目标方法，性能稍低。

4. CGLIB 动态代理实现原理

CGLIB 动态代理是一种基于子类的代理机制，它通过生成目标类的子类来实现代理。CGLIB 动态代理使用 ASM 字节码生成库，在运行时生成字节码，重写父类的方法以插入增强逻辑。

CGLIB 代理的步骤

生成子类代理：CGLIB 通过创建目标类的子类来代理目标类，使用 Enhancer 类来生成代理对象。
方法拦截：代理类会拦截所有的父类方法，并在方法调用时调用 MethodInterceptor 的 intercept 方法。
调用目标方法：在 intercept 方法中可以插入增强逻辑，然后通过 MethodProxy.invokeSuper() 调用原始方法。

示例代码：

javaCopy codeimport org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxyExample {

    static class Service {
        public void perform() {
            System.out.println("Executing Service logic");
        }
    }

    static class ServiceInterceptor implements MethodInterceptor {
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("Before executing method");
            Object result = proxy.invokeSuper(obj, args); // 调用目标方法
            System.out.println("After executing method");
            return result;
        }
    }

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service.class);
        enhancer.setCallback(new ServiceInterceptor());

        Service proxy = (Service) enhancer.create();
        proxy.perform();
    }
}

优点：

能代理没有实现接口的类。
基于字节码操作，性能高于 JDK 动态代理。

缺点：

不能代理 final 类和 final 方法。
生成子类代理对象，增加了内存消耗。

5. Spring AOP 如何选择代理方式

Spring AOP 根据目标类的类型选择合适的代理方式：

接口代理优先：Spring 默认优先使用 JDK 动态代理，如果目标类实现了接口，Spring 会自动使用 JDK 动态代理。
无接口时使用 CGLIB：当目标类没有实现接口，Spring 会使用 CGLIB 生成代理对象。
强制使用 CGLIB：可以通过 @EnableAspectJAutoProxy(proxyTargetClass = true) 或 XML 配置 <aop:config proxy-target-class="true"/> 强制使用 CGLIB 代理。

Spring 的自动代理选择机制如下：

如果 proxyTargetClass=true 或目标类未实现接口，则使用 CGLIB 动态代理。
否则，使用 JDK 动态代理。

6. Spring AOP 的执行流程

AOP 配置：当 Spring 启动时，根据 @Aspect 或 XML 配置加载切面，解析切点表达式和通知方法。
代理创建：根据代理选择策略为目标类创建代理对象（JDK 或 CGLIB）。
方法调用拦截：当调用代理对象的方法时，Spring AOP 拦截该方法调用，并根据切面配置执行通知方法。
通知链执行：Spring AOP 为每个通知生成一个拦截器，并形成一个拦截器链。方法调用时，按顺序执行前置通知、目标方法、后置通知等。

7. 总结

代理选择：Spring AOP 使用 JDK 动态代理和 CGLIB 动态代理，根据目标类的情况自动选择代理方式。
适用场景：JDK 动态代理适合接口代理，CGLIB 适合无接口代理。可以通过配置强制使用 CGLIB。
优缺点：JDK 动态代理轻量简单，CGLIB 适合无接口代理且性能更高，但无法代理 final 类和方法。

Spring AOP 通过动态代理机制实现了灵活的面向切面编程功能，帮助开发者轻松实现事务管理、日志记录等横切关注点。