Java动态代理与InvocationHandler缓存清理的艺术

在Java编程中，动态代理是一种强大的机制，允许我们在运行时创建代理对象，实现对目标对象的增强。然而，随着动态代理的广泛应用，缓存清理问题也逐渐浮出水面。本文将探讨如何巧妙地处理InvocationHandler中的缓存清理，提升系统性能和稳定性。

动态代理与InvocationHandler简介

Java动态代理依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。通过实现InvocationHandler接口，我们可以在调用目标方法前后插入自定义逻辑。以下是一个简单的动态代理示例：

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

interface MyService {
    void performAction();
}

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

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");
        Object result = method.invoke(target, args);
        System.out.println("After method");
        return result;
    }
}

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

缓存清理的必要性

在实际应用中，InvocationHandler可能会缓存一些数据以提高性能。例如，缓存方法调用的结果、状态信息等。然而，长时间不清理这些缓存会导致内存泄漏，影响系统稳定性。

缓存清理策略

1. 定时清理

我们可以使用定时任务来定期清理缓存。Java中的ScheduledExecutorService是不错的选择：

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class MyInvocationHandlerWithCache implements InvocationHandler {
    private final Object target;
    private final ConcurrentHashMap<Method, Object> cache = new ConcurrentHashMap<>();

    public MyInvocationHandlerWithCache(Object target) {
        this.target = target;
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(this::clearCache, 1, 1, TimeUnit.HOURS);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (cache.containsKey(method)) {
            return cache.get(method);
        }
        Object result = method.invoke(target, args);
        cache.put(method, result);
        return result;
    }

    private void clearCache() {
        cache.clear();
    }
}

2. 引用计数

利用java.lang.ref.Reference类族，我们可以实现引用计数，当缓存对象不再被使用时自动清理：

import java.lang.ref.WeakReference;
import java.util.WeakHashMap;

class MyInvocationHandlerWithRefCount implements InvocationHandler {
    private final Object target;
    private final WeakHashMap<Method, WeakReference<Object>> cache = new WeakHashMap<>();

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        WeakReference<Object> ref = cache.get(method);
        if (ref != null && ref.get() != null) {
            return ref.get();
        }
        Object result = method.invoke(target, args);
        cache.put(method, new WeakReference<>(result));
        return result;
    }
}

3. 事件驱动清理

在某些场景下，我们可以根据特定事件来触发缓存清理，例如用户登出、会话结束等：

class MyInvocationHandlerWithEventDrivenCleanup implements InvocationHandler {
    private final Object target;
    private final ConcurrentHashMap<Method, Object> cache = new ConcurrentHashMap<>();

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (cache.containsKey(method)) {
            return cache.get(method);
        }
        Object result = method.invoke(target, args);
        cache.put(method, result);
        return result;
    }

    public void onEvent(String event) {
        if ("SESSION_END".equals(event)) {
            cache.clear();
        }
    }
}