Spring AOP动态代理

人不走空

发布于 2024-02-25 10:12:17

1110

发布于 2024-02-25 10:12:17

文章被收录于专栏：学习与分享学习与分享

在软件开发中，AOP（面向切面编程）是一种重要的编程范式，它允许开发者在程序运行时动态地将额外的逻辑织入到现有代码中，以实现诸如日志记录、事务管理、性能监控等横切关注点的功能。而动态代理作为 AOP 的重要实现方式之一，在许多场景下被广泛应用。

本文将介绍如何使用 AOP 实现动态代理，并以 GitHub 风格的方式展示其实现过程。

什么是 AOP？

AOP 是一种编程范式，它允许开发者将横切关注点（cross-cutting concerns）从应用程序的核心逻辑中分离出来。横切关注点是那些散布于应用程序中多个模块中的功能，如日志记录、安全性和事务管理等。

什么是动态代理？

动态代理是一种在运行时创建代理类和对象的方式，而不是在编译时确定。在 Java 中，动态代理通常通过 java.lang.reflect.Proxy 类实现。它允许在运行时创建一个实现了一组给定接口的代理类，该代理类可以将方法调用转发到委托对象，并在调用前后执行额外的逻辑。

AOP 中的动态代理

在 AOP 中，动态代理用于实现横切关注点的功能。通常，AOP 框架会创建代理类来织入额外的逻辑，并将其应用到目标对象的方法调用上。

让我们以一个简单的示例来说明如何使用 AOP 实现动态代理。假设我们有一个接口 UserService，其中定义了一个方法 void addUser(String username)，我们希望在每次调用该方法时记录日志。

public interface UserService {
    void addUser(String username);
}

首先，我们需要一个日志切面类，它包含在每次方法调用前后记录日志的逻辑。

public class LoggingAspect {
    public void beforeAddUser(String username) {
        System.out.println("Adding user: " + username);
    }
    
    public void afterAddUser(String username) {
        System.out.println("User added: " + username);
    }
}

然后，我们创建一个动态代理类 UserServiceProxy，它实现了 UserService 接口，并在方法调用前后调用日志切面类的方法。

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

public class UserServiceProxy implements InvocationHandler {
    private UserService target;
    private LoggingAspect aspect;

    public UserServiceProxy(UserService target, LoggingAspect aspect) {
        this.target = target;
        this.aspect = aspect;
    }

    public static UserService createProxy(UserService target, LoggingAspect aspect) {
        return (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new UserServiceProxy(target, aspect)
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result;
        try {
            aspect.beforeAddUser((String) args[0]);
            result = method.invoke(target, args);
            aspect.afterAddUser((String) args[0]);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            throw e;
        }
        return result;
    }
}

最后，我们可以在应用程序中使用动态代理来创建 UserService 的代理对象，并调用其方法。

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        LoggingAspect loggingAspect = new LoggingAspect();

        UserService proxy = UserServiceProxy.createProxy(userService, loggingAspect);
        proxy.addUser("john_doe");
    }
}

在这个示例中，每次调用 proxy.addUser("john_doe") 时，都会先打印 "Adding user: john_doe"，然后调用实际的 UserService 对象的 addUser 方法，最后打印 "User added: john_doe"。