Java动态代理之InvocationHandler代理链管理

在Java编程中，动态代理是一种强大的机制，它允许我们在运行时创建一个代理对象，实现对目标对象的增强。而InvocationHandler作为动态代理的核心组件，负责拦截对代理对象的所有方法调用。本文将深入探讨如何通过InvocationHandler实现代理链的管理，从而构建更加灵活和可扩展的代理模式。

代理链的基本概念

代理链（Proxy Chain）是指在动态代理中，多个InvocationHandler按照一定顺序组合起来，形成一个处理链。每个InvocationHandler可以独立地处理方法调用，也可以将调用传递给链中的下一个InvocationHandler。这种设计模式类似于责任链模式，使得代理逻辑更加模块化和可复用。

实现代理链管理

定义基础接口

首先，定义一个基础接口，代理对象和目标对象都需要实现该接口：

public interface BaseService {
    void performAction();
}

创建目标对象

接下来，创建一个实现了BaseService接口的目标对象：

public class TargetService implements BaseService {
    @Override
    public void performAction() {
        System.out.println("TargetService: performAction");
    }
}

定义InvocationHandler

我们需要定义多个InvocationHandler，每个InvocationHandler负责不同的代理逻辑：

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

public class LoggingHandler implements InvocationHandler {
    private final Object target;

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

public class MonitoringHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long endTime = System.currentTimeMillis();
        System.out.println("Method " + method.getName() + " took " + (endTime - startTime) + " ms");
        return result;
    }
}

构建代理链

为了管理代理链，我们可以创建一个工厂类来生成带有多个InvocationHandler的代理对象：

public class ProxyChainFactory {
    public static BaseService createProxyChain(BaseService target) {
        BaseService loggingProxy = (BaseService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new LoggingHandler(target)
        );

        BaseService monitoringProxy = (BaseService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new MonitoringHandler(loggingProxy)
        );

        return monitoringProxy;
    }
}

使用代理链

最后，我们可以使用工厂类来创建代理对象，并调用方法：

public class Main {
    public static void main(String[] args) {
        BaseService target = new TargetService();
        BaseService proxy = ProxyChainFactory.createProxyChain(target);
        proxy.performAction();
    }
}

输出结果将是：

Before method: performAction
TargetService: performAction
After method: performAction
Method performAction took XX ms

总结

通过InvocationHandler实现代理链管理，我们可以灵活地组合多种代理逻辑，使得代码更加模块化和可维护。本文介绍了代理链的基本概念、实现方法以及如何在实际应用中使用代理链。希望这篇文章能帮助你更好地理解和应用Java动态代理技术。