在现代应用开发中，缓存是提升系统性能的关键手段。为了兼顾本地缓存的高性能和分布式缓存的扩展能力，常见的实现方式是结合使用 Caffeine 和 Redis 实现二级缓存架构。

本文将详细介绍如何通过 Spring Boot 实现一个Caffeine + Redis 二级缓存，并通过合理的架构设计和代码实现，确保缓存的一致性、性能和容错性。

一、 需求与挑战

1.多级缓存的需求：

•一级缓存（Caffeine）：快速响应，存储本地热点数据，减少对远程缓存和数据库的访问。

•二级缓存（Redis）：共享缓存数据，支持分布式扩展。

2.常见问题：

•数据一致性：一级缓存和二级缓存之间的数据如何保持同步？

•容错性：Redis 不可用时如何保证系统稳定运行？

•缓存穿透：如何避免大量无效请求穿透缓存直接访问数据库？

•高并发：如何避免缓存击穿导致数据库压力激增？

二、 缓存设计与解决方案

2.1 缓存查询流程

按照Cache-Aside 模式，缓存查询流程如下：

1.查询一级缓存（Caffeine）：

•如果命中，则直接返回结果。

2.查询二级缓存（Redis）：

•如果 Redis 有数据，则回填到一级缓存，并返回结果。

•如果 Redis 查询失败（Redis 不可用），直接跳过。

3.查询数据源（数据库等）：

•如果 Redis 也未命中，则从数据源获取数据，同时回填到一级和二级缓存中。

2.2 缓存更新流程

•数据更新或写入时，同时更新一级和二级缓存。

•如果 Redis 写入失败，仅更新一级缓存，确保数据可用性。

三、代码实现

3.1 缓存接口设计

定义一个通用的缓存接口，便于不同实现类的扩展和切换：

import java.util.Collection;import java.util.Map;import java.util.Set;import java.util.function.Supplier;public interface CacheService {    <T> T get(String key, Class<T> type, Supplier<T> dataLoader); // 获取单个键的数据    void put(String key, Object value); // 存储单个键的数据    void evict(String key); // 删除单个键    boolean exists(String key); // 检查键是否存在    Map<String, Object> getAll(Set<String> keys); // 批量获取多个键的数据    Object getHash(String key, String hashKey); // 获取哈希表中单个字段的值    void putHash(String key, String hashKey, Object value); // 存储哈希表中的字段    void evictAll(Collection<String> keys); // 批量删除多个键}

3.2 Caffeine + Redis 实现

使用 Caffeine 和 Redis 的结合实现二级缓存：

import com.github.benmanes.caffeine.cache.Cache;import com.github.benmanes.caffeine.cache.Caffeine;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;import java.util.function.Supplier;@Servicepublic class OptimizedCacheService implements CacheService {    private final Cache<String, Object> caffeineCache;    private final RedisTemplate<String, Object> redisTemplate;    public OptimizedCacheService(RedisTemplate<String, Object> redisTemplate) {        this.caffeineCache = Caffeine.newBuilder()                .initialCapacity(100)                .maximumSize(1000)                .expireAfterWrite(10, TimeUnit.MINUTES)                .build();        this.redisTemplate = redisTemplate;    }    @Override    public <T> T get(String key, Class<T> type, Supplier<T> dataLoader) {        // Step 1: 查询一级缓存（Caffeine）        T value = (T) caffeineCache.getIfPresent(key);        if (value != null) {            return value;        }        // Step 2: 查询二级缓存（Redis）        try {            value = (T) redisTemplate.opsForValue().get(key);            if (value != null) {                // 回填到一级缓存                caffeineCache.put(key, value);                return value;            }        } catch (Exception e) {            // Redis 不可用时记录日志            System.err.println("Redis 不可用：" + e.getMessage());        }        // Step 3: 查询数据源（数据库等）        value = dataLoader.get();        if (value != null) {            // 回填到缓存            caffeineCache.put(key, value);            try {                redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);            } catch (Exception e) {                System.err.println("Redis 存储失败：" + e.getMessage());            }        }        return value;    }    @Override    public void put(String key, Object value) {        // 同时更新一级缓存和二级缓存        caffeineCache.put(key, value);        try {            redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);        } catch (Exception e) {            System.err.println("Redis 存储失败：" + e.getMessage());        }    }    @Override    public void evict(String key) {        // 同时移除一级缓存和二级缓存        caffeineCache.invalidate(key);        try {            redisTemplate.delete(key);        } catch (Exception e) {            System.err.println("Redis 删除失败：" + e.getMessage());        }    }      @Overridepublic boolean exists(String key) {    // 检查一级缓存    if (caffeineCache.asMap().containsKey(key)) {        return true;    }    // 检查二级缓存    try {        return Boolean.TRUE.equals(redisTemplate.hasKey(key));    } catch (Exception e) {        System.err.println("Redis 检查键失败：" + e.getMessage());        return false;    }}
@Overridepublic Map<String, Object> getAll(Set<String> keys) {    // 优先从一级缓存中获取    Map<String, Object> result = caffeineCache.getAllPresent(keys);    // 还需要获取的键    Set<String> missingKeys = keys.stream()            .filter(key -> !result.containsKey(key))            .collect(Collectors.toSet());    if (!missingKeys.isEmpty()) {        try {            // 从 Redis 获取剩余的键            List<Object> redisResults = redisTemplate.opsForValue().multiGet(missingKeys);            if (redisResults != null) {                for (int i = 0; i < missingKeys.size(); i++) {                    String key = missingKeys.toArray(new String[0])[i];                    Object value = redisResults.get(i);                    if (value != null) {                        result.put(key, value);                        caffeineCache.put(key, value); // 回填一级缓存                    }                }            }        } catch (Exception e) {            System.err.println("Redis 批量获取失败：" + e.getMessage());        }    }    return result;}
@Overridepublic Object getHash(String key, String hashKey) {    try {        return redisTemplate.opsForHash().get(key, hashKey);    } catch (Exception e) {        System.err.println("Redis 获取哈希字段失败：" + e.getMessage());        return null;    }}@Overridepublic void putHash(String key, String hashKey, Object value) {    try {        redisTemplate.opsForHash().put(key, hashKey, value);    } catch (Exception e) {        System.err.println("Redis 存储哈希字段失败：" + e.getMessage());    }}
@Overridepublic void evictAll(Collection<String> keys) {    // 删除一级缓存    caffeineCache.invalidateAll(keys);    // 删除二级缓存    try {        redisTemplate.delete(keys);    } catch (Exception e) {        System.err.println("Redis 批量删除失败：" + e.getMessage());    }}}

3.3 空值缓存（防止缓存穿透）

为了避免查询不存在的数据穿透到数据库，可以将空值存储到缓存中：

if (value == null) {    // 存储空值到缓存，防止穿透    caffeineCache.put(key, "NULL");    try {        redisTemplate.opsForValue().set(key, "NULL", 1, TimeUnit.MINUTES);    } catch (Exception e) {        System.err.println("Redis 存储空值失败：" + e.getMessage());    }    return null;}if ("NULL".equals(value)) {    return null;}

3.4 异步更新 Redis（提升写性能）

为了提高写操作性能，可以将 Redis 的更新操作放到异步线程中：

private void asyncUpdateRedis(String key, Object value) {    new Thread(() -> {        try {            redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);        } catch (Exception e) {            System.err.println("Redis 异步更新失败：" + e.getMessage());        }    }).start();}

在put和get方法中调用asyncUpdateRedis。

3.5 定时清理 Caffeine

Caffeine 默认是惰性清理（Lazy Cleanup）。如果需要主动清理，可以通过定时任务触发：

@Scheduled(fixedRate = 60000) // 每分钟执行一次public void cleanUpCache() {    caffeineCache.cleanUp();}

四、总结与优势

4.1 架构特点

1.性能更高：直接按一级缓存 -> 二级缓存 -> 数据库的顺序查询，减少了 Redis 可用性检查的开销。

2.降级容错：当 Redis 不可用时，不影响数据加载和缓存更新。

3.缓存一致性：通过回填机制，尽量保持一级缓存和二级缓存的数据一致性。

4.可扩展性：支持空值缓存、异步更新、主动清理等增强功能。

4.2 应用场景

•高频访问的数据（如热门商品、热点新闻）。

•分布式应用需要共享缓存的数据。

•对性能和容错性有较高要求的业务场景。

通过 Caffeine 和 Redis 的结合，可以构建一个高效、灵活、稳定的二级缓存架构，有效提升系统性能并降低后端服务压力。