Java Interceptor如何实现缓存机制

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑。要实现缓存机制，你可以在拦截器中检查方法的输入参数，然后根据这些参数查询缓存。如果缓存中有结果，就直接返回结果，否则执行方法并将结果存入缓存。

以下是一个简单的示例，展示了如何使用Java拦截器实现缓存机制：

1. 首先，创建一个缓存接口：

public interface Cache<K, V> {
    V get(K key);
    void put(K key, V value);
}

2. 实现一个简单的内存缓存：

import java.util.HashMap;
import java.util.Map;

public class SimpleCache<K, V> implements Cache<K, V> {
    private final Map<K, V> cache = new HashMap<>();

    @Override
    public V get(K key) {
        return cache.get(key);
    }

    @Override
    public void put(K key, V value) {
        cache.put(key, value);
    }
}

3. 创建一个拦截器类：

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

public class CacheInterceptor<K, V> implements InvocationHandler {
    private final Object target;
    private final Cache<K, V> cache;

    public CacheInterceptor(Object target, Cache<K, V> cache) {
        this.target = target;
        this.cache = cache;
    }

    public static <K, V> V createProxy(Object target, Cache<K, V> cache) {
        return (V) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new CacheInterceptor<>(target, cache)
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        K key = (K) args[0];
        V result = cache.get(key);

        if (result == null) {
            result = method.invoke(target, args);
            cache.put(key, result);
        }

        return result;
    }
}

4. 使用拦截器为需要缓存的方法添加缓存功能：

public interface SomeService {
    String getData(String key);
}

public class SomeServiceImpl implements SomeService {
    @Override
    public String getData(String key) {
        System.out.println("Fetching data from source...");
        return "data for " + key;
    }
}

public class Main {
    public static void main(String[] args) {
        SomeService someService = new SomeServiceImpl();
        Cache<String, String> cache = new SimpleCache<>();
        SomeService cachedService = CacheInterceptor.createProxy(someService, cache);

        System.out.println(cachedService.getData("key1")); // Fetching data from source... data for key1
        System.out.println(cachedService.getData("key1")); // data for key1 (from cache)
    }
}

在这个示例中，我们创建了一个名为CacheInterceptor的拦截器，它实现了InvocationHandler接口。拦截器会在方法调用前后检查缓存，并根据需要执行缓存逻辑。我们还创建了一个简单的SimpleCache类来实现缓存接口。

要使用拦截器，你需要为目标对象创建一个代理，将拦截器和目标对象传递给CacheInterceptor.createProxy()方法。然后，你可以像平常一样调用代理对象的方法。拦截器会自动处理缓存逻辑。