Java动态代理之InvocationHandler嵌套调用探秘

在Java编程中，动态代理是一种强大的机制，允许我们在运行时创建一个代理对象，实现对目标对象的增强。而InvocationHandler作为动态代理的核心组件，更是扮演着至关重要的角色。本文将深入探讨InvocationHandler的嵌套调用，揭示其在实际应用中的独特魅力。

初识InvocationHandler

InvocationHandler是一个接口，定义了invoke方法，该方法在代理对象的方法被调用时执行。通过实现invoke方法，我们可以拦截并增强目标对象的方法调用。以下是一个简单的InvocationHandler实现示例：

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

public class SimpleInvocationHandler implements InvocationHandler {
    private final Object target;

    public SimpleInvocationHandler(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;
    }
}

嵌套调用的需求

在实际应用中，我们可能需要对同一个目标对象进行多层增强，例如在业务逻辑前后添加日志、权限校验、事务管理等。此时，单一InvocationHandler可能无法满足需求，嵌套调用便应运而生。

实现嵌套调用

嵌套调用是指在一个InvocationHandler中调用另一个InvocationHandler。通过这种方式，我们可以将多个增强逻辑层层嵌套，实现复杂的增强效果。以下是一个嵌套调用的示例：

public class LoggingInvocationHandler implements InvocationHandler {
    private final InvocationHandler nextHandler;

    public LoggingInvocationHandler(InvocationHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Logging before method: " + method.getName());
        Object result = nextHandler.invoke(proxy, method, args);
        System.out.println("Logging after method: " + method.getName());
        return result;
    }
}

public class TransactionInvocationHandler implements InvocationHandler {
    private final InvocationHandler nextHandler;

    public TransactionInvocationHandler(InvocationHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Start transaction");
        Object result = nextHandler.invoke(proxy, method, args);
        System.out.println("Commit transaction");
        return result;
    }
}

使用嵌套调用

现在，我们可以将多个InvocationHandler嵌套使用，实现对目标对象的层层增强：

public class Main {
    public static void main(String[] args) {
        // 目标对象
        SomeService target = new SomeServiceImpl();

        // 创建嵌套的InvocationHandler
        InvocationHandler handler = new TransactionInvocationHandler(
            new LoggingInvocationHandler(
                new SimpleInvocationHandler(target)
            )
        );

        // 创建代理对象
        SomeService proxy = (SomeService) Proxy.newProxyInstance(
            SomeService.class.getClassLoader(),
            new Class<?>[] { SomeService.class },
            handler
        );

        // 调用代理对象的方法
        proxy.doSomething();
    }
}