Java动态代理在AOP编程中的实际应用

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

// 假设这是我们的业务接口
interface MyService {
    void doSomething(String taskName);
    String getData(int id);
}

// 业务接口的实现
class MyServiceImpl implements MyService {
    @Override
    public void doSomething(String taskName) {
        System.out.println("Executing: " + taskName);
        // 模拟业务逻辑
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    @Override
    public String getData(int id) {
        System.out.println("Fetching data for ID: " + id);
        return "Data for " + id;
    }
}

// 日志代理处理器
class LogInvocationHandler implements InvocationHandler {
    private final Object target; // 真正的业务对象

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();
        System.out.println("[日志] 方法 " + method.getName() + " 开始执行，参数: " + Arrays.toString(args));

        Object result = null;
        try {
            // 调用原始方法
            result = method.invoke(target, args);
            return result;
        } catch (Exception e) {
            System.err.println("[日志] 方法 " + method.getName() + " 执行异常: " + e.getMessage());
            throw e; // 重新抛出异常，保持原有的异常行为
        } finally {
            long endTime = System.nanoTime();
            long duration = (endTime - startTime) / 1_000_000; // 毫秒
            System.out.println("[日志] 方法 " + method.getName() + " 执行完毕，耗时: " + duration + "ms，结果: " + result);
        }
    }
}

public class DynamicProxyLogDemo {
    public static void main(String[] args) {
        MyService myService = new MyServiceImpl();

        // 创建代理对象
        MyService proxyService = (MyService) Proxy.newProxyInstance(
            myService.getClass().getClassLoader(), // 类加载器
            myService.getClass().getInterfaces(),   // 目标对象实现的接口
            new LogInvocationHandler(myService)     // 我们的日志处理器
        );

        // 通过代理对象调用方法
        System.out.println("\n--- 调用 doSomething ---");
        proxyService.doSomething("清理缓存");

        System.out.println("\n--- 调用 getData ---");
        String data = proxyService.getData(123);
        System.out.println("实际获取到的数据: " + data);

        System.out.println("\n--- 模拟异常调用 ---");
        try {
            // 假设 getData 方法在 id 为 999 时会抛出异常
            // 这里为了演示，我们让 invoke 内部模拟抛出
            // 实际业务中，是 myService.getData(999) 抛出
            // LogInvocationHandler 会捕获并记录
            proxyService.getData(999);
        } catch (Exception e) {
            System.out.println("主程序捕获到异常: " + e.getMessage());
        }
    }
}

// 伪代码示例：事务代理
class TransactionalInvocationHandler implements InvocationHandler {
    private final Object target;
    // 假设这里有获取数据库连接的逻辑
    // private DataSource dataSource;

    public TransactionalInvocationHandler(Object target /*, DataSource dataSource */) {
        this.target = target;
        // this.dataSource = dataSource;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // Connection connection = dataSource.getConnection(); // 获取连接
        // connection.setAutoCommit(false); // 关闭自动提交

        Object result = null;
        try {
            System.out.println("[事务] 开启事务...");
            result = method.invoke(target, args); // 执行业务方法
            // connection.commit(); // 提交事务
            System.out.println("[事务] 事务提交成功。");
            return result;
        } catch (Exception e) {
            // connection.rollback(); // 回滚事务
            System.err.println("[事务] 事务回滚，原因: " + e.getMessage());
            throw e; // 重新抛出异常
        } finally {
            // connection.setAutoCommit(true); // 恢复自动提交
            // connection.close(); // 关闭连接
            System.out.println("[事务] 事务处理结束。");
        }
    }
}

// 伪代码示例：权限代理
// 假设有一个 @RequiresPermission("admin") 注解
// 假设有一个 UserContext.getCurrentUserRole() 方法

class PermissionInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1. 检查方法是否需要特定权限
        RequiresPermission permissionAnnotation = method.getAnnotation(RequiresPermission.class);
        if (permissionAnnotation != null) {
            String requiredRole = permissionAnnotation.value();
            String currentUserRole = "guest"; // UserContext.getCurrentUserRole(); // 模拟获取当前用户角色

            // 假设这里是根据业务逻辑判断
            if ("admin".equals(requiredRole) && !"admin".equals(currentUserRole)) {
                System.err.println("[权限] 拒绝访问: 用户角色 '" + currentUserRole + "' 无权执行方法 '" + method.getName() + "' (需要 '" + requiredRole + "')");
                throw new SecurityException("Access Denied: Insufficient permissions.");
            }
            System.out.println("[权限] 权限检查通过，用户角色: " + currentUserRole);
        } else {
            System.out.println("[权限] 方法 " + method.getName() + " 无需特定权限检查。");
        }

        // 2. 如果权限检查通过，执行原始方法
        return method.invoke(target, args);
    }
}