深入剖析 Spring AOP 底层原理

原创

wx6711fcec17e8e 2024-10-18 14:21:11 ©著作权

文章标签 动态代理 AOP System 文章分类 Java 后端开发 用AIGC写一篇爆文

©著作权归作者所有：来自51CTO博客作者wx6711fcec17e8e的原创作品，请联系作者获取转载授权，否则将追究法律责任

在 Java 开发的世界里，Spring AOP（Aspect-Oriented Programming，面向切面编程）无疑是一个强大的工具，它为我们提供了一种优雅的方式来实现横切关注点的分离，极大地提高了代码的可维护性和可扩展性。现在，让我们更深入地探究 Spring AOP 的底层原理。

一、Spring AOP 的核心概念

切面（Aspect）：一个切面定义了一个特定的关注点，比如日志记录、事务管理等。它由切点和增强组成。
切点（Pointcut）：切点用于指定在哪些地方应用增强。它可以通过表达式来匹配特定的方法执行点。
增强（Advice）：增强定义了在切点匹配的方法执行前后或出现异常时要执行的逻辑。常见的增强类型有前置通知（Before advice）、后置通知（After advice）、环绕通知（Around advice）等。

二、Spring AOP 的实现方式

Spring AOP 主要通过两种方式实现动态代理：JDK 动态代理和 CGLIB 动态代理。

JDK 动态代理：

JDK 动态代理是基于接口实现的。当目标对象实现了一个或多个接口时，Spring 会使用 JDK 动态代理来创建代理对象。
在代码层面，通过java.lang.reflect.Proxy类来生成代理对象。这个代理对象会拦截对目标对象方法的调用，并在调用前后或者出现异常时执行我们定义的增强逻辑。
例如，以下是一个更复杂的 JDK 动态代理示例：

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

interface TargetInterface {
    void complexMethod(int param1, String param2);
}

class TargetImpl implements TargetInterface {
    @Override
    public void complexMethod(int param1, String param2) {
        System.out.println("执行目标方法，参数 1：" + param1 + "，参数 2：" + param2);
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("在目标方法执行前，方法名：" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("在目标方法执行后，方法名：" + method.getName());
        return result;
    }
}

public class AdvancedJdkDynamicProxyExample {
    public static void main(String[] args) {
        TargetInterface target = new TargetImpl();
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new MyInvocationHandler(target));
        proxy.complexMethod(123, "Hello World");
    }
}

CGLIB 动态代理：

当目标对象没有实现任何接口时，Spring 会使用 CGLIB 动态代理。
CGLIB 通过继承目标类来创建子类，在子类中重写需要增强的方法，从而实现增强逻辑。
例如，以下是一个 CGLIB 动态代理的示例：

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

class TargetClass {
    public void targetMethod() {
        System.out.println("执行目标方法");
    }
}

class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("在目标方法执行前");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("在目标方法执行后");
        return result;
    }
}

public class CglibDynamicProxyExample {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TargetClass.class);
        enhancer.setCallback(new MyMethodInterceptor());
        TargetClass proxy = (TargetClass) enhancer.create();
        proxy.targetMethod();
    }
}

三、Spring AOP 的工作流程