Java Interceptor 拦截器如何实现缓存

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑。要实现缓存功能，你可以在拦截器中检查方法的输入参数，然后根据这些参数从缓存中获取结果。如果缓存中没有结果，就执行方法并将结果存入缓存。这里是一个简单的示例，使用Java动态代理实现拦截器和缓存功能：

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

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

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

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. 创建一个拦截器类，实现InvocationHandler接口：

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;
    }

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

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

        return result;
    }

    private K generateKey(Method method, Object[] args) {
        // 根据方法名和参数生成缓存键，这里只是一个简单的示例，你可能需要根据实际情况调整
        return (K) (method.getName() + Arrays.deepToString(args));
    }
}

4. 使用Proxy.newProxyInstance()创建代理对象：

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

5. 使用拦截器：

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

public class MyServiceImpl implements MyService {
    @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) {
        MyService target = new MyServiceImpl();
        Cache<String, String> cache = new SimpleCache<>();
        MyService proxy = CacheProxyFactory.createProxy(target, cache);

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

这个示例中，我们创建了一个简单的缓存拦截器，它可以缓存实现了某个接口的对象的方法调用结果。你可以根据实际需求调整这个示例，例如使用更复杂的缓存键生成策略、支持缓存失效等。