Spring AOP概念及原理-数字星空

Spring AOP（面向切面编程）

以下内容由ChatGPT生成

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过分离关注点来提高程序的模块化。Spring AOP 主要用于横切关注点（如日志记录、安全、事务管理等）的实现。在 Spring 中，AOP 的主要功能是为 Bean 增强功能，如添加额外的行为。

1. 静态代理与动态代理

静态代理和动态代理是实现 AOP 的两种主要方式。

静态代理：

在编译时就已经知道代理的目标类，代理类在代码中显式地定义。
静态代理的缺点是需要为每个代理的类手动编写代理类，导致代码冗余且难以维护。

动态代理：

动态代理是在运行时生成代理类的，Java 中有两种实现动态代理的方式：JDK 动态代理和 CGLIB。
动态代理的优点是可以为任意接口生成代理，不需要手动编写代理类。

JDK 动态代理

JDK 动态代理只代理实现了接口的类。它通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口实现。
InvocationHandler 接口中定义了 invoke 方法，当代理对象调用方法时，会执行该方法。

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

public class JdkProxyExample {
public static void main(String[] args) {
Foo foo = new FooImpl();
Foo proxyFoo = (Foo) Proxy.newProxyInstance(
Foo.class.getClassLoader(),
new Class<?>[]{Foo.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 前置增强
System.out.println("Before method: " + method.getName());
Object result = method.invoke(foo, args);
// 后置增强
System.out.println("After method: " + method.getName());
return result;
}
});
proxyFoo.doSomething();
}
}

interface Foo {
void doSomething();
}

class FooImpl implements Foo {
public void doSomething() {
System.out.println("Doing something...");
}
}

CGLIB 动态代理

CGLIB 动态代理通过生成目标类的子类来实现代理，因此可以代理没有接口的类。CGLIB 使用 ASM 字节码操作库来生成代理类。
CGLIB 的代理类重写目标类的方法，通过调用父类的 super 方法来实现对目标方法的调用。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxyExample {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Foo.class);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
// 前置增强
System.out.println("Before method: " + method.getName());
Object result = proxy.invokeSuper(obj, args);
// 后置增强
System.out.println("After method: " + method.getName());
return result;
}
});
Foo fooProxy = (Foo) enhancer.create();
fooProxy.doSomething();
}
}

class Foo {
public void doSomething() {
System.out.println("Doing something...");
}
}

2. Spring AOP 实现原理

Spring AOP 支持 JDK 动态代理和 CGLIB 两种代理机制。

JDK 动态代理：当目标类实现了一个或多个接口时，Spring 默认使用 JDK 动态代理来为目标类创建代理对象。
CGLIB：如果目标类没有实现任何接口，Spring 则会使用 CGLIB 来生成目标类的代理对象。

Spring 使用 AopProxy 接口和其两个实现类 JdkDynamicAopProxy 和 CglibAopProxy 来分别处理这两种代理机制。

Bean 被包装成 Proxy

Spring 容器启动时，解析配置文件或注解，生成 Bean 定义信息。
在 Bean 初始化后，Spring AOP 的 BeanPostProcessor 之一（如 AbstractAutoProxyCreator 的子类）会检查该 Bean 是否需要 AOP 增强。
如果需要增强，则会生成一个代理对象，替换掉原始的 Bean。这一过程是通过调用 getProxy() 方法来完成的。

创建 Proxy 对象

AopProxy 接口定义了 getProxy() 方法：

JdkDynamicAopProxy：通过 JDK 动态代理的 Proxy.newProxyInstance() 方法创建代理对象。
CglibAopProxy：通过 CGLIB 的 Enhancer 类创建代理对象。

获取代理对象

getProxy() 方法返回代理对象。代理对象的创建是在调用 getProxy() 方法时动态生成的，并且在这个方法中处理了所有的 AOP 增强逻辑。

InvocationHandler 的实现

在 JDK 动态代理中，InvocationHandler 的 invoke() 方法包含了拦截器链的逻辑。CglibAopProxy 通过 Callback 和 MethodInterceptor 实现类似的功能。

public class MyInvocationHandler implements InvocationHandler {
private final Object target;

public MyInvocationHandler(Object target) {
this.target = target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 前置处理
System.out.println("Before method: " + method.getName());

// 调用目标对象的方法
Object result = method.invoke(target, args);

// 后置处理
System.out.println("After method: " + method.getName());

return result;
}
}

在 invoke() 方法中：

执行前置增强逻辑。
使用反射调用目标对象的方法。
执行后置增强逻辑。

3. 拦截器链与方法链的执行

Spring AOP 中的拦截器链是由 Advisor 和 MethodInterceptor 组成的。Advisor 包含切点（Pointcut）和通知（Advice），切点定义了哪些方法需要拦截，通知则定义了拦截时执行的逻辑。

在代理对象调用方法时：

AopProxy 调用链会依次调用拦截器链中的拦截器。
拦截器链通过责任链模式处理每一个拦截器。
如果拦截器链中的某个拦截器决定执行目标方法，则会调用 MethodInvocation.proceed() 方法。

public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
// 前置处理
System.out.println("Before method: " + invocation.getMethod().getName());

// 调用目标对象的方法
Object result = invocation.proceed();

// 后置处理
System.out.println("After method: " + invocation.getMethod().getName());

return result;
}
}

在 invoke() 方法中，proceed() 方法用于继续执行下一个拦截器或目标方法。如果没有其他拦截器，则执行目标方法。

总结

Spring AOP 使用代理模式实现横切关注点的管理，主要通过 JDK 动态代理和 CGLIB 动态代理实现。代理对象是通过 AopProxy 创建的，其中的 InvocationHandler 和 MethodInterceptor 负责执行拦截器链的逻辑。Spring AOP 提供了强大的功能来增强 Bean 的行为，使得切面逻辑与核心业务逻辑分离，提升了代码的模块化和可维护性。