【Spring Boot】Spring AOP动态代理，以及静态代理

在Spring框架中，面向切面编程（AOP）是一个重要的特性，它允许我们将横切关注点（如日志记录、安全检查、事务管理等）从业务逻辑中分离出来。AOP的实现主要依赖于动态代理和静态代理。在这篇文章中，我们将详细探讨这两种代理方式，并给出相应的代码示例。

一、静态代理

静态代理是在编译时就确定代理关系的。它需要手动编写代理类，并在代理类中持有被代理类的实例。静态代理的缺点是无法复用代码，因为每一个被代理的类都需要一个对应的代理类。

以下是静态代理的示例：

// 被代理的接口
public interface UserService {
    void addUser();
}

// 被代理的实现类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}

// 静态代理类
public class UserServiceProxy implements UserService {
    private UserService userService;

    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void addUser() {
        // 代理增强逻辑
        System.out.println("开始事务");
        userService.addUser(); // 调用被代理方法
        System.out.println("提交事务");
    }
}

// 主程序
public class StaticProxyTest {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy(userService);
        proxy.addUser();
    }
}

在上面的代码中，UserServiceProxy类充当了UserServiceImpl的代理，通过在addUser方法前后添加事务处理逻辑，实现了增强的功能。

二、动态代理

动态代理是在运行时生成代理对象，这意味着你可以在不修改被代理类的情况下，对其进行增强。在Java中，动态代理一般有两种实现方式：JDK动态代理和CGLIB代理。

1. JDK动态代理

JDK动态代理只支持接口代理。以下是JDK动态代理的示例：

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

// 被代理的接口
public interface UserService {
    void addUser();
}

// 被代理的实现类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}

// 动态代理处理器
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 代理增强逻辑
        System.out.println("开始事务");
        Object result = method.invoke(target, args); // 调用被代理方法
        System.out.println("提交事务");
        return result;
    }
}

// 主程序
public class DynamicProxyTest {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(
                UserService.class.getClassLoader(),
                new Class[]{UserService.class},
                new DynamicProxyHandler(userService));
        proxyInstance.addUser();
    }
}

2. CGLIB代理

CGLIB是一个强大的代码生成库，它允许你在运行时生成目标类的子类，从而实现代理。CGLIB代理不需要接口，可以直接对类进行增强。

以下是CGLIB代理的示例：

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

// 被代理的类
public class UserService {
    public void addUser() {
        System.out.println("添加用户");
    }
}

// CGLIB代理
public class CglibProxy implements MethodInterceptor {
    private Object target;

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

    @Override
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 代理增强逻辑
        System.out.println("开始事务");
        Object result = proxy.invoke(target, args); // 调用被代理方法
        System.out.println("提交事务");
        return result;
    }
}

// 主程序
public class CglibProxyTest {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new CglibProxy(new UserService()));

        UserService proxyInstance = (UserService) enhancer.create();
        proxyInstance.addUser();
    }
}

总结

静态代理和动态代理各有优缺点。静态代理实现简单，但不够灵活；动态代理虽然较为复杂，但能够做到代码的复用和增强，尤其在Spring AOP中，其力求将关注点分离，实现更清晰的代码设计。选择哪种代理方式，依赖于具体的应用场景与需求。Spring AOP通常使用动态代理的方式，使得开发者无需关注底层实现，专注于业务逻辑的开发。