Java动态代理与InvocationHandler代理链缓存策略

在Java编程中，动态代理是一种强大的机制，允许我们在运行时创建代理对象，实现对目标对象的增强。而InvocationHandler则是这一机制的核心组件，负责拦截并处理所有对代理对象的调用。本文将深入探讨如何通过代理链和缓存策略优化InvocationHandler的性能。

动态代理的基本概念

动态代理基于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现。通过Proxy.newProxyInstance方法，我们可以创建一个代理对象，该对象在调用任何方法时，都会委托给InvocationHandler处理。

public interface MyService {
    void performAction();
}

public class MyServiceImpl implements MyService {
    @Override
    public void performAction() {
        System.out.println("Action performed");
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

public class ProxyDemo {
    public static void main(String[] args) {
        MyService service = new MyServiceImpl();
        MyService proxy = (MyService) Proxy.newProxyInstance(
            MyService.class.getClassLoader(),
            new Class<?>[] { MyService.class },
            new MyInvocationHandler(service)
        );
        proxy.performAction();
    }
}

代理链的实现

在实际应用中，我们可能需要对同一个目标对象进行多重增强，这时可以使用代理链。代理链由多个InvocationHandler组成，每个InvocationHandler负责不同的增强逻辑。

public class ProxyChain {
    private final List<InvocationHandler> handlers;
    private final Object target;

    public ProxyChain(Object target, List<InvocationHandler> handlers) {
        this.target = target;
        this.handlers = handlers;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return new ProxyChainInvocation(proxy, method, args, 0).proceed();
    }

    private class ProxyChainInvocation {
        private final Object proxy;
        private final Method method;
        private final Object[] args;
        private int index;

        public ProxyChainInvocation(Object proxy, Method method, Object[] args, int index) {
            this.proxy = proxy;
            this.method = method;
            this.args = args;
            this.index = index;
        }

        public Object proceed() throws Throwable {
            if (index >= handlers.size()) {
                return method.invoke(target, args);
            }
            return handlers.get(index).invoke(proxy, method, args);
        }
    }
}

缓存策略的引入

在代理链中，每个InvocationHandler可能会进行一些重复的计算，导致性能下降。为了优化性能，我们可以引入缓存策略。

缓存的基本思路

方法签名作为键：使用方法名和参数类型作为缓存的键。
结果作为值：将方法调用的结果存储在缓存中。
过期策略：根据需要实现简单的过期策略，如LRU（最近最少使用）。

缓存实现示例

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class CachingInvocationHandler implements InvocationHandler {
    private final InvocationHandler nextHandler;
    private final Map<String, Object> cache = new ConcurrentHashMap<>();

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String key = method.getName() + Arrays.toString(args);
        if (cache.containsKey(key)) {
            System.out.println("Cache hit for: " + key);
            return cache.get(key);
        }
        System.out.println("Cache miss for: " + key);
        Object result = nextHandler.invoke(proxy, method, args);
        cache.put(key, result);
        return result;
    }
}