如何利用Java Interceptor实现缓存

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑。要利用Java拦截器实现缓存，你可以使用动态代理或者AOP（面向切面编程）框架，如Spring AOP。下面是一个简单的示例，展示如何使用Java动态代理实现缓存拦截器。

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

public interface Cache {
    Object get(String key);
    void put(String key, Object value);
}

然后，实现一个简单的内存缓存：

public class SimpleCache implements Cache {
    private 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);
    }
}

接下来，创建一个拦截器类，实现InvocationHandler接口：

public class CacheInterceptor implements InvocationHandler {
    private Object target;
    private 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 methodName = method.getName();
        if (methodName.startsWith("get")) {
            String key = args[0].toString();
            Object cachedValue = cache.get(key);
            if (cachedValue != null) {
                return cachedValue;
            }
        }

        Object result = method.invoke(target, args);
        if (methodName.startsWith("put")) {
            String key = args[0].toString();
            cache.put(key, result);
        }
        return result;
    }
}

现在，你可以使用CacheInterceptor为任何对象创建代理实例，以实现缓存功能。例如，假设你有一个UserService接口：

public interface UserService {
    User getUserById(int id);
    void addUser(User user);
}

你可以创建一个UserService的实现类：

public class UserServiceImpl implements UserService {
    @Override
    public User getUserById(int id) {
        // 从数据库或其他数据源获取用户信息
        return new User(id, "John Doe");
    }

    @Override
    public void addUser(User user) {
        // 将用户信息添加到数据库或其他数据源
    }
}

最后，使用CacheInterceptor为UserService创建代理实例：

public class Main {
    public static void main(String[] args) {
        Cache cache = new SimpleCache();
        UserService userService = new UserServiceImpl();
        UserService userServiceWithCache = (UserService) Proxy.newProxyInstance(
                UserService.class.getClassLoader(),
                new Class<?>[]{UserService.class},
                new CacheInterceptor(userService, cache)
        );

        // 第一次调用getUserById，将从数据库获取用户信息
        User user1 = userServiceWithCache.getUserById(1);

        // 第二次调用getUserById，将从缓存中获取用户信息
        User user2 = userServiceWithCache.getUserById(1);

        // 调用addUser，将用户信息添加到数据库
        userServiceWithCache.addUser(new User(2, "Jane Doe"));

        // 第三次调用getUserById，将从数据库获取用户信息，因为缓存中没有ID为2的用户
        User user3 = userServiceWithCache.getUserById(2);
    }
}

这个示例展示了如何使用Java动态代理实现一个简单的缓存拦截器。在实际项目中，你可能需要根据需求对这个示例进行扩展和优化。如果你使用Spring AOP或其他AOP框架，实现缓存拦截器会更加简单和灵活。