如何用Java Interceptor实现缓存

在Java中，使用拦截器（Interceptor）实现缓存通常涉及到以下几个步骤：

1. 定义缓存策略：首先，你需要定义一个缓存策略，这可能包括缓存的过期时间、最大容量等。

2. 创建拦截器类：创建一个实现了拦截器接口的类，这个类将负责拦截方法调用，并在适当的时候从缓存中获取数据或更新缓存。

3. 配置拦截器：在你的应用程序中配置拦截器，使其能够拦截特定的方法调用。

下面是一个简单的例子，展示了如何使用Java的动态代理来实现一个基本的缓存拦截器：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

// 缓存接口
interface Cache {
    Object get(String key);
    void put(String key, Object value);
}

// 简单的内存缓存实现
class SimpleCache implements Cache {
    private final Map<String, Object> cache = new HashMap<>();

    @Override
    public Object get(String key) {
        return cache.get(key);
    }

    @Override
    public void put(String key, Object value) {
        cache.put(key, value);
    }
}

// 缓存拦截器
class CacheInterceptor implements InvocationHandler {
    private final Object target;
    private final Cache cache;

    public CacheInterceptor(Object target, Cache cache) {
        this.target = target;
        this.cache = cache;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 假设方法的第一个参数是缓存的键
        String key = (String) args[0];
        Object cachedValue = cache.get(key);

        if (cachedValue != null) {
            System.out.println("从缓存中获取数据: " + key);
            return cachedValue;
        } else {
            System.out.println("从目标方法获取数据: " + key);
            Object result = method.invoke(target, args);
            cache.put(key, result);
            return result;
        }
    }
}

// 业务接口
interface BusinessService {
    String getData(String key);
}

// 业务实现
class BusinessServiceImpl implements BusinessService {
    @Override
    public String getData(String key) {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "data for " + key;
    }
}

public class CacheDemo {
    public static void main(String[] args) {
        BusinessService target = new BusinessServiceImpl();
        Cache cache = new SimpleCache();
        BusinessService proxy = (BusinessService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new CacheInterceptor(target, cache)
        );

        // 第一次调用，将会触发真实的方法
        System.out.println(proxy.getData("key1"));

        // 第二次调用，将会从缓存中获取
        System.out.println(proxy.getData("key1"));
    }
}

在这个例子中，我们定义了一个Cache接口和一个简单的实现SimpleCache。然后，我们创建了一个CacheInterceptor类，它实现了InvocationHandler接口，并在invoke方法中添加了缓存逻辑。最后，我们使用Proxy.newProxyInstance方法创建了一个代理对象，该对象会在调用getData方法时使用我们的缓存拦截器。

请注意，这个例子非常简单，实际应用中可能需要考虑线程安全、缓存失效策略、缓存穿透、缓存雪崩等问题。此外，对于分布式系统，你可能需要使用更复杂的缓存解决方案，如Redis或Memcached。