Java 工业级多级缓存架构设计与落地（Redis 客户端+Redisson 方案）

核心结论：Caffeine 是当前 Java 本地缓存的最优选择——性能比 Guava Cache 快 10 倍以上（基于 W-TinyLFU 淘汰算法），支持更多工业级特性，且 Spring Boot 2.3+ 已默认集成，无需额外依赖。

2.2 工业级 Caffeine 配置与实战

（1）统一常量类（系列共用，标准化配置）

/** * 缓存统一常量类（本地缓存 + 分布式缓存共用） */
public class CacheConstants {
    // 本地缓存前缀（避免 Key 冲突）
    public static final String LOCAL_CACHE_PREFIX = "local:cache:";
    // 分布式缓存前缀（Redis/Redisson 共用）
    public static final String DISTRIBUTED_CACHE_PREFIX = "distributed:cache:";
    // 本地缓存核心配置
    public static final int LOCAL_CACHE_MAX_SIZE = 10000; // 最大容量（JVM 堆内存 10%-15%）
    public static final long LOCAL_CACHE_EXPIRE_SECONDS = 30 * 60; // 写入后过期（30 分钟）
    public static final long LOCAL_CACHE_HOT_EXPIRE_SECONDS = 2 * 60 * 60; // 热点数据过期（2 小时）
    // 分布式缓存核心配置
    public static final long DISTRIBUTED_CACHE_DEFAULT_EXPIRE_SECONDS = 60 * 60; // 默认过期（1 小时）
    public static final long DISTRIBUTED_CACHE_HOT_EXPIRE_SECONDS = 3 * 60 * 60; // 热点数据过期（3 小时）
    public static final long DELAY_DOUBLE_DELETE_MILLIS = 500; // 延迟双删时间（500 毫秒）
    // 分布式锁配置
    public static final String LOCK_PREFIX = "distributed:lock:";
    public static final long LOCK_WAIT_TIME = 10; // 锁等待时间（10 秒）
    public static final long LOCK_LEASE_TIME = 30; // 锁持有时间（30 秒）
}

（2）Caffeine 配置类（Spring Bean 管理，全局复用）

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@Configuration
public class CaffeineConfig {
    /** * 本地缓存核心 Bean（工业级最优配置） */
    @Bean
    public LoadingCache<String, Object> localCache() {
        return Caffeine.newBuilder()
            // 最大容量（避免 OOM，根据 JVM 堆内存调整）
            .maximumSize(CacheConstants.LOCAL_CACHE_MAX_SIZE)
            // 写入后过期策略（平衡一致性与性能）
            .expireAfterWrite(CacheConstants.LOCAL_CACHE_EXPIRE_SECONDS, TimeUnit.SECONDS)
            // 开启缓存统计（命中率、缺失率，用于监控优化）
            .recordStats()
            // 异步加载线程池（核心线程数=CPU 核心数，避免阻塞业务线程）
            .executor(Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()))
            // 缓存移除监听器（日志打印，便于排查缓存失效原因）
            .removalListener((key, value, cause) -> System.out.printf("本地缓存移除：key=%s，原因=%s%n", key, cause.name()))
            // 缓存缺失时的加载逻辑（此处留空，业务层手动实现，灵活度更高）
            .build(key -> null);
    }
}

（3）本地缓存业务层封装（工业级规范）

import com.github.benmanes.caffeine.cache.LoadingCache;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

@Service
public class LocalCacheService {
    @Resource
    private LoadingCache<String, Object> localCache;

    /** * 缓存存入（自动拼接前缀，避免 Key 冲突） */
    public void put(String key, Object value) {
        put(key, value, CacheConstants.LOCAL_CACHE_EXPIRE_SECONDS);
    }

    /** * 缓存存入（自定义过期时间，适配热点数据） */
    public void put(String key, Object value, long expireSeconds) {
        if (key == null || value == null) {
            throw new IllegalArgumentException("缓存 Key/Value 不能为空");
        }
        String cacheKey = CacheConstants.LOCAL_CACHE_PREFIX + key;
        localCache.put(cacheKey, value);
        // 热点数据延长过期时间（可选，根据业务标记）
        if (expireSeconds > CacheConstants.LOCAL_CACHE_EXPIRE_SECONDS) {
            localCache.policy().expireAfterWrite().ifPresent(policy -> policy.setExpiresAfter(cacheKey, expireSeconds, TimeUnit.SECONDS));
        }
    }

    /** * 缓存获取（未命中返回 null，异常降级避免影响业务） */
    public Object get(String key) {
        if (key == null) {
            return null;
        }
        String cacheKey = CacheConstants.LOCAL_CACHE_PREFIX + key;
        try {
            return localCache.get(cacheKey);
        } catch (Exception e) {
            System.err.printf("本地缓存查询异常：key=%s，异常信息=%s%n", key, e.getMessage());
            return null; // 异常降级，放行到分布式缓存
        }
    }

    /** * 缓存删除（支持批量删除） */
    public void remove(String key) {
        if (key == null) {
            return;
        }
        String cacheKey = CacheConstants.LOCAL_CACHE_PREFIX + key;
        localCache.invalidate(cacheKey);
    }

    public void removeBatch(Iterable<String> keys) {
        if (keys == null) {
            return;
        }
        Iterable<String> cacheKeys = () -> keys.iterator().forEachRemaining(k -> CacheConstants.LOCAL_CACHE_PREFIX + k);
        localCache.invalidateAll(cacheKeys);
    }

    /** * 获取缓存统计信息（生产监控必备） */
    public String getCacheStats() {
        com.github.benmanes.caffeine.cache.Stats stats = localCache.stats();
        return String.format("本地缓存命中率：%.2f%%，缺失率：%.2f%%，加载成功数：%d，加载失败数：%d", stats.hitRate() * 100, stats.missRate() * 100, stats.loadSuccessCount(), stats.loadFailureCount());
    }
}

三、分布式缓存方案一：Redis 原生客户端实现（Lettuce+Jedis）

3.1 Redis 客户端深度对比（Lettuce vs Jedis）

Redis 原生客户端是直接与 Redis 交互的工具，核心对比决定了选型优先级：

核心结论：无特殊场景一律选择 Lettuce——Spring Boot 默认集成，开发成本低，异步非阻塞模型适配高并发，集群支持完善；Jedis 仅作为'旧项目兼容'或'需原生命令操作'的备用方案。

3.2 Lettuce 工业级实现（首选方案）

（1）前置依赖（Spring Boot 原生整合）

<!-- Spring Data Redis（默认集成 Lettuce） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 序列化依赖（Fastjson2，解决 Redis 存储乱码问题） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.41</version>
</dependency>

（2）工业级配置（application.yml）

spring:
  redis:
    # 集群配置（单机模式：直接配置 host 和 port，无需 cluster 节点）
    cluster:
      nodes:
        - 192.168.1.100:6379
        - 192.168.1.101:6379
        - 192.168.1.102:6379
      max-redirects: 3 # 集群最大重定向次数
    # 基础配置
    password: your-redis-password # 生产环境必须配置，避免裸奔
    timeout: 3000ms # 连接超时 + 读取超时（避免无限阻塞）
    database: 0 # 选择 Redis 数据库（默认 0，按业务隔离）
    # Lettuce 连接池配置（核心优化，提升并发性能）
    lettuce:
      pool:
        max-active: 16 # 最大连接数（CPU 核心数*2，避免连接池耗尽）
        max-idle: 8 # 最大空闲连接数（与 max-active 保持一致，减少连接创建开销）
        min-idle: 4 # 最小空闲连接数（保证基础并发需求）
        max-wait: -1ms # 最大等待时间（-1 表示无限制，避免线程阻塞）
        shutdown-timeout: 100ms # 关闭超时时间（优雅关闭连接，避免资源泄露）

（3）RedisTemplate 配置（序列化优化）

默认 RedisTemplate 使用 JDK 序列化，会导致存储乱码、占用空间大，需替换为 Fastjson2 序列化：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONWriter;
import com.alibaba.fastjson2.serializer.SerializerFeature;

@Configuration
public class RedisLettuceConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 1. Key 序列化：StringRedisSerializer（避免 Key 乱码，兼容 Redis 命令行查询）
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(keySerializer);
        redisTemplate.setHashKeySerializer(keySerializer);
        // 2. Value 序列化：Fastjson2（高效、无乱码、支持复杂对象）
        Fastjson2RedisSerializer valueSerializer = new Fastjson2RedisSerializer(Object.class);
        redisTemplate.setValueSerializer(valueSerializer);
        redisTemplate.setHashValueSerializer(valueSerializer);
        // 3. 初始化 RedisTemplate（必须调用，否则配置不生效）
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /** * 自定义 Fastjson2 Redis 序列化器（工业级配置） */
    public static class Fastjson2RedisSerializer<T> extends org.springframework.data.redis.serializer.RedisSerializer<T> {
        private final Class<T> clazz;

        public Fastjson2RedisSerializer(Class<T> clazz) {
            this.clazz = clazz;
        }

        @Override
        public byte[] serialize(T t) {
            if (t == null) {
                return new byte[0];
            }
            // 序列化配置：日期格式化、禁用循环引用、空值保留（避免反序列化丢失字段）
            return JSON.toJSONBytes(t, JSONWriter.Feature.WriteDateUseDateFormat, JSONWriter.Feature.DisableCircularReferenceDetect, JSONWriter.Feature.WriteNullsAsEmpty);
        }

        @Override
        public T deserialize(byte[] bytes) {
            if (bytes == null || bytes.length == 0) {
                return null;
            }
            return JSON.parseObject(bytes, clazz);
        }
    }
}

（4）Lettuce 业务层封装（工业级规范）

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Service
public class RedisLettuceCacheService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /** * 缓存存入（默认过期时间） */
    public void put(String key, Object value) {
        put(key, value, CacheConstants.DISTRIBUTED_CACHE_DEFAULT_EXPIRE_SECONDS);
    }

    /** * 缓存存入（自定义过期时间，支持热点数据延长过期） */
    public void put(String key, Object value, long expireSeconds) {
        if (key == null || value == null) {
            throw new IllegalArgumentException("缓存 Key/Value 不能为空");
        }
        String cacheKey = CacheConstants.DISTRIBUTED_CACHE_PREFIX + key;
        try {
            redisTemplate.opsForValue().set(cacheKey, value, expireSeconds, TimeUnit.SECONDS);
        } catch (Exception e) {
            // 缓存写入异常降级（仅日志打印，不影响业务主流程）
            System.err.printf("Lettuce 缓存写入异常：key=%s，异常信息=%s%n", key, e.getMessage());
        }
    }

    /** * 缓存存入空值（解决缓存穿透问题） */
    public void putNullValue(String key) {
        put(key, new NullValue(), 60); // 空值缓存 1 分钟，避免占用过多内存
    }

    /** * 缓存获取（未命中返回 null，空值缓存返回 NullValue） */
    public Object get(String key) {
        if (key == null) {
            return null;
        }
        String cacheKey = CacheConstants.DISTRIBUTED_CACHE_PREFIX + key;
        try {
            Object value = redisTemplate.opsForValue().get(cacheKey);
            // 空值缓存判断（避免穿透到数据库）
            return value instanceof NullValue ? null : value;
        } catch (Exception e) {
            System.err.printf("Lettuce 缓存查询异常：key=%s，异常信息=%s%n", key, e.getMessage());
            return null; // 异常降级，放行到数据库
        }
    }

    /** * 缓存删除（支持单 Key 和批量删除） */
    public void remove(String key) {
        if (key == null) {
            return;
        }
        String cacheKey = CacheConstants.DISTRIBUTED_CACHE_PREFIX + key;
        try {
            redisTemplate.delete(cacheKey);
        } catch (Exception e) {
            System.err.printf("Lettuce 缓存删除异常：key=%s，异常信息=%s%n", key, e.getMessage());
        }
    }

    public void removeBatch(Iterable<String> keys) {
        if (keys == null) {
            return;
        }
        Iterable<String> cacheKeys = () -> keys.iterator().forEachRemaining(k -> CacheConstants.DISTRIBUTED_CACHE_PREFIX + k);
        try {
            redisTemplate.delete(cacheKeys);
        } catch (Exception e) {
            System.err.printf("Lettuce 缓存批量删除异常，异常信息=%s%n", e.getMessage());
        }
    }

    /** * 延迟双删（解决 Redis 主从同步延迟导致的脏读） */
    public void delayDoubleRemove(String key) {
        remove(key);
        // 延迟 500 毫秒再次删除（适配主从同步延迟）
        CacheThreadPool.DELAY_DELETE_EXECUTOR.schedule(() -> remove(key), CacheConstants.DELAY_DOUBLE_DELETE_MILLIS, TimeUnit.MILLISECONDS);
    }

    /** * 空值缓存占位符（避免与业务空值混淆） */
    private static class NullValue {}
}

/** * 缓存专用线程池（统一管理，避免线程泄露） */
class CacheThreadPool {
    public static final java.util.concurrent.ScheduledExecutorService DELAY_DELETE_EXECUTOR = java.util.concurrent.Executors.newScheduledThreadPool(5, new java.util.concurrent.ThreadFactory() {
        private int count = 0;

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("cache-delay-delete-" + (++count));
            thread.setDaemon(true); // 守护线程，不影响应用关闭
            return thread;
        }
    });
}

3.3 Jedis 工业级实现（备用方案）

（1）前置依赖（排除 Lettuce，引入 Jedis）

<!-- Spring Data Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <!-- 排除 Lettuce 依赖 -->
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 引入 Jedis 依赖 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.4.6</version>
</dependency>
<!-- 序列化依赖（Fastjson2） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.41</version>
</dependency>

（2）Jedis 配置类（连接池+RedisTemplate）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisJedisConfig {
    /** * Jedis 连接池配置（工业级参数） */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(16); // 最大连接数（与 Lettuce 保持一致）
        poolConfig.setMaxIdle(8); // 最大空闲连接数
        poolConfig.setMinIdle(4); // 最小空闲连接数
        poolConfig.setMaxWaitMillis(-1); // 最大等待时间（-1 表示无限制）
        poolConfig.setTestOnBorrow(true); // 借出连接时测试可用性（避免使用无效连接）
        poolConfig.setTestOnReturn(true); // 归还连接时测试可用性
        return poolConfig;
    }

    /** * Jedis 连接工厂（集群/单机适配） */
    @Bean
    public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig poolConfig) {
        JedisConnectionFactory factory = new JedisConnectionFactory(poolConfig);
        // 单机配置（集群配置需替换为 RedisClusterConfiguration）
        factory.setHostName("192.168.1.100");
        factory.setPort(6379);
        factory.setPassword("your-redis-password");
        factory.setTimeout(3000); // 超时时间
        factory.setDatabase(0);
        return factory;
    }

    /** * RedisTemplate 配置（与 Lettuce 共用序列化逻辑） */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // Key 序列化：StringRedisSerializer
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(keySerializer);
        redisTemplate.setHashKeySerializer(keySerializer);
        // Value 序列化：Fastjson2（复用 Lettuce 的序列化器）
        RedisLettuceConfig.Fastjson2RedisSerializer valueSerializer = new RedisLettuceConfig.Fastjson2RedisSerializer(Object.class);
        redisTemplate.setValueSerializer(valueSerializer);
        redisTemplate.setHashValueSerializer(valueSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

（3）Jedis 业务层封装（与 Lettuce API 对齐）

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Service
public class RedisJedisCacheService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // 以下方法与 RedisLettuceCacheService 完全一致，API 对齐，便于切换
    public void put(String key, Object value) {
        put(key, value, CacheConstants.DISTRIBUTED_CACHE_DEFAULT_EXPIRE_SECONDS);
    }

    public void put(String key, Object value, long expireSeconds) {
        if (key == null || value == null) {
            throw new IllegalArgumentException("缓存 Key/Value 不能为空");
        }
        String cacheKey = CacheConstants.DISTRIBUTED_CACHE_PREFIX + key;
        try {
            redisTemplate.opsForValue().set(cacheKey, value, expireSeconds, TimeUnit.SECONDS);
        } catch (Exception e) {
            System.err.printf("Jedis 缓存写入异常：key=%s，异常信息=%s%n", key, e.getMessage());
        }
    }

    public void putNullValue(String key) {
        put(key, new RedisLettuceCacheService.NullValue(), 60);
    }

    public Object get(String key) {
        if (key == null) {
            return null;
        }
        String cacheKey = CacheConstants.DISTRIBUTED_CACHE_PREFIX + key;
        try {
            Object value = redisTemplate.opsForValue().get(cacheKey);
            return value instanceof RedisLettuceCacheService.NullValue ? null : value;
        } catch (Exception e) {
            System.err.printf("Jedis 缓存查询异常：key=%s，异常信息=%s%n", key, e.getMessage());
            return null;
        }
    }

    public void remove(String key) {
        if (key == null) {
            return;
        }
        String cacheKey = CacheConstants.DISTRIBUTED_CACHE_PREFIX + key;
        try {
            redisTemplate.delete(cacheKey);
        } catch (Exception e) {
            System.err.printf("Jedis 缓存删除异常：key=%s，异常信息=%s%n", key, e.getMessage());
        }
    }

    public void delayDoubleRemove(String key) {
        remove(key);
        CacheThreadPool.DELAY_DELETE_EXECUTOR.schedule(() -> remove(key), CacheConstants.DELAY_DOUBLE_DELETE_MILLIS, TimeUnit.MILLISECONDS);
    }
}

四、分布式缓存方案二：Redisson 实现（分布式高级功能首选）

4.1 Redisson 核心定位与优势

Redisson 不是单纯的 Redis 客户端，而是「基于 Redis 构建的分布式服务框架」——它将 Redis 的基础命令封装成了开箱即用的分布式工具，核心优势如下：

1. 高级功能丰富：内置分布式锁、延迟队列、分布式集合、布隆过滤器等，无需手动封装（如分布式锁的自动续期、红锁实现）；
2. API 极度友好：完全屏蔽 Redis 原生命令，用面向对象的方式操作（如 RLock.lock()、RMap.put()），学习成本低；
3. 高可用设计：自动处理连接重试、锁过期、集群故障转移，无需手动编写容错逻辑；
4. 集群原生支持：无缝适配 Redis 单机、哨兵、分片集群，配置简单；
5. 缓存功能完善：支持过期策略、缓存淘汰、持久化，兼顾基础缓存与高级功能。

核心定位：适合分布式架构下需要高级功能（如分布式锁、延迟队列）的场景，或追求快速开发、降低容错成本的项目。

4.2 Redisson 工业级配置

（1）前置依赖（Redisson Spring Boot Starter）

<!-- Redisson Spring Boot Starter（自动整合 Spring） -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.5</version>
</dependency>
<!-- 序列化依赖（Fastjson2，与 Redis 客户端保持一致） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.41</version>
</dependency>

（2）application.yml 配置（集群/单机兼容）

spring:
  redis:
    password: your-redis-password
    timeout: 3000ms # Redisson 配置（独立配置，更灵活）
  redisson:
    config: |
      singleServerConfig:
        address: "redis://192.168.1.100:6379" # 单机模式（集群模式替换为 clusterServersConfig）
        password: "your-redis-password"
        timeout: 3000
        connectionPoolSize: 16 # 连接池大小（与 Lettuce 保持一致）
        connectionMinimumIdleSize: 4 # 最小空闲连接数
        # 集群模式配置（替换 singleServerConfig）
        # clusterServersConfig:
        #   nodeAddresses:
        #     - "redis://192.168.1.100:6379"
        #     - "redis://192.168.1.101:6379"
        #   password: "your-redis-password"
        #   timeout: 3000
        #   scanInterval: 2000 # 集群节点扫描间隔
      serializer:
        # 序列化配置（与 Redis 客户端保持一致，避免数据不一致）
        type: org.redisson.codec.FastJson2Codec

（3）RedissonClient 配置类（Spring Bean 管理）

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {
    @Value("${redisson.config}")
    private String redissonConfig;

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        // 加载配置（支持字符串、文件、URL 多种方式）
        Config config = Config.fromYAML(redissonConfig);
        // 创建 RedissonClient 实例（全局唯一，线程安全）
        return Redisson.create(config);
    }
}

4.3 Redisson 缓存与高级功能实战

（1）Redisson 基础缓存实现（分布式 Map）

import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Service
public class RedissonCacheService {
    @Resource
    private RedissonClient redissonClient;

    /** * 获取分布式 Map（缓存容器） */
    private <K, V> RMap<K, V> getCacheMap() {
        // 缓存 Key 前缀（与 Redis 客户端保持一致，避免 Key 冲突）
        return redissonClient.getMap(CacheConstants.DISTRIBUTED_CACHE_PREFIX);
    }

    /** * 缓存存入（支持过期时间） */
    public void put(String key, Object value) {
        put(key, value, CacheConstants.DISTRIBUTED_CACHE_DEFAULT_EXPIRE_SECONDS);
    }

    public void put(String key, Object value, long expireSeconds) {
        if (key == null || value == null) {
            throw new IllegalArgumentException("缓存 Key/Value 不能为空");
        }
        RMap<String, Object> cacheMap = getCacheMap();
        try {
            cacheMap.put(key, value);
            // 设置过期时间（Key 级过期）
            cacheMap.expire(key, expireSeconds, TimeUnit.SECONDS);
        } catch (Exception e) {
            System.err.printf("Redisson 缓存写入异常：key=%s，异常信息=%s%n", key, e.getMessage());
        }
    }

    /** * 缓存存入空值（解决缓存穿透） */
    public void putNullValue(String key) {
        put(key, new NullValue(), 60);
    }

    /** * 缓存获取 */
    public Object get(String key) {
        if (key == null) {
            return null;
        }
        RMap<String, Object> cacheMap = getCacheMap();
        try {
            Object value = cacheMap.get(key);
            return value instanceof NullValue ? null : value;
        } catch (Exception e) {
            System.err.printf("Redisson 缓存查询异常：key=%s，异常信息=%s%n", key, e.getMessage());
            return null;
        }
    }

    /** * 缓存删除 */
    public void remove(String key) {
        if (key == null) {
            return;
        }
        RMap<String, Object> cacheMap = getCacheMap();
        try {
            cacheMap.remove(key);
        } catch (Exception e) {
            System.err.printf("Redisson 缓存删除异常：key=%s，异常信息=%s%n", key, e.getMessage());
        }
    }

    /** * 空值占位符 */
    private static class NullValue {}
}

（2）Redisson 核心高级功能：分布式锁（解决缓存击穿）

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Component
public class RedissonLockUtil {
    @Resource
    private RedissonClient redissonClient;

    /** * 获取分布式锁（非阻塞，失败返回 false）
     * @param lockKey 锁 Key
     * @return 锁实例（释放锁需调用 unlock()） */
    public RLock tryLock(String lockKey) {
        return tryLock(lockKey, CacheConstants.LOCK_WAIT_TIME, CacheConstants.LOCK_LEASE_TIME);
    }

    /** * 自定义等待时间和持有时间 */
    public RLock tryLock(String lockKey, long waitTime, long leaseTime) {
        if (lockKey == null) {
            throw new IllegalArgumentException("锁 Key 不能为空");
        }
        String key = CacheConstants.LOCK_PREFIX + lockKey;
        // 获取锁实例（支持红锁：redissonClient.getRedLock(locks)）
        RLock lock = redissonClient.getLock(key);
        try {
            // 尝试获取锁：最多等待 waitTime 秒，持有 leaseTime 秒后自动释放（避免死锁）
            boolean locked = lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
            return locked ? lock : null;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        }
    }

    /** * 释放锁（必须在 finally 中调用） */
    public void unlock(RLock lock) {
        if (lock != null && lock.isHeldByCurrentThread()) {
            try {
                lock.unlock();
            } catch (Exception e) {
                System.err.printf("释放分布式锁异常，异常信息=%s%n", e.getMessage());
            }
        }
    }
}

（3）Redisson 核心高级功能：延迟队列（优化延迟双删）

import org.redisson.api.RDelayedQueue;
import org.redisson.api.RQueue;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Component
public class RedissonDelayQueueUtil {
    @Resource
    private RedissonClient redissonClient;

    // 延迟队列名称（统一管理）
    private static final String DELAY_QUEUE_NAME = "distributed:delay:queue";

    /** * 添加延迟任务（如延迟双删、订单超时取消）
     * @param task 任务内容（需序列化）
     * @param delay 延迟时间
     * @param timeUnit 时间单位 */
    public <T> void addDelayTask(T task, long delay, TimeUnit timeUnit) {
        if (task == null) {
            throw new IllegalArgumentException("任务内容不能为空");
        }
        // 获取队列实例
        RQueue<T> queue = redissonClient.getQueue(DELAY_QUEUE_NAME);
        RDelayedQueue<T> delayedQueue = redissonClient.getDelayedQueue(queue);
        // 添加延迟任务
        delayedQueue.offer(task, delay, timeUnit);
    }

    /** * 监听延迟任务（应用启动时执行，阻塞监听） */
    public <T> void listenDelayTask(Class<T> taskClass, DelayTaskHandler<T> handler) {
        RQueue<T> queue = redissonClient.getQueue(DELAY_QUEUE_NAME);
        RDelayedQueue<T> delayedQueue = redissonClient.getDelayedQueue(queue);
        // 循环监听任务（线程安全，阻塞式）
        while (true) {
            try {
                T task = queue.take();
                if (task != null) {
                    handler.handle(task);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (Exception e) {
                System.err.printf("处理延迟任务异常，异常信息=%s%n", e.getMessage());
            }
        }
    }

    /** * 任务处理接口（回调） */
    @FunctionalInterface
    public interface DelayTaskHandler<T> {
        void handle(T task);
    }
}

/** * 延迟双删任务（示例） */
class CacheDelayDeleteTask {
    private String key;
    // 省略 getter/setter/构造方法
}

/** * 延迟队列初始化（应用启动时执行） */
@Component
class DelayQueueInitializer {
    @Resource
    private RedissonDelayQueueUtil delayQueueUtil;
    @Resource
    private RedissonCacheService redissonCacheService;

    // 应用启动后执行
    public void init() {
        // 监听延迟双删任务
        delayQueueUtil.listenDelayTask(CacheDelayDeleteTask.class, task -> {
            String key = task.getKey();
            redissonCacheService.remove(key);
            System.out.printf("延迟双删任务执行：key=%s%n", key);
        });
    }
}

五、核心选型对比与场景适配（重点）

5.1 三大方案全面对比表

5.2 典型场景选型指南（直接落地参考）

1. 高并发核心业务（如电商商品详情、支付接口）
   • 选型：Caffeine+Redis+Lettuce
   • 理由：Lettuce 异步非阻塞模型支撑高并发，Caffeine 减少网络开销，性能最优；
   • 补充：用 Redisson 分布式锁解决缓存击穿（热点 Key 过期）。
2. 旧项目缓存改造（已集成 Jedis）
   • 选型：Caffeine+Redis+Jedis
   • 理由：无需大规模修改代码，优化 Jedis 连接池参数即可提升性能；
   • 避坑：确保连接池复用，避免连接泄露。
3. 分布式架构 + 快速开发（如中台系统、内部工具）
   • 选型：Caffeine+Redisson
   • 理由：Redisson 开箱即用分布式锁、延迟队列，开发效率高，无需手动封装；
   • 优势：兼顾基础缓存与高级功能，减少依赖冲突。
4. 分布式锁/延迟队列等高级需求（如秒杀、订单超时取消）
   • 选型：Redisson（必选）
   • 理由：Redisson 红锁解决单点故障，自动续期避免死锁，延迟队列稳定可靠；
   • 替代方案：Redis+Lettuce 需手动封装，容错成本高。
5. 中小并发、单体应用（如管理后台、工具类项目）
   • 选型：Caffeine+Redis+Lettuce 或 Caffeine+Redisson
   • 理由：配置简单，无需复杂集群，满足性能需求即可。
6. 需直接操作 Redis 原生命令（如自定义协议、特殊命令）
   • 选型：Redis+Jedis 或 Redis+Lettuce（execute 方法）
   • 理由：Jedis API 更贴近原生命令，Lettuce 需通过 RedisConnection.execute() 调用。

5.3 选型决策流程（三步法）

1. 看并发量：高并发（1 万 QPS 以上）→ 优先 Lettuce；中低并发→ 可选 Redisson/Jedis；
2. 看功能需求：需分布式锁/延迟队列→ Redisson；仅基础缓存→ Lettuce/Jedis；
3. 看技术栈：Spring Boot 2.x+→ 优先 Lettuce；旧项目→ 优先 Jedis；快速开发→ Redisson。

六、工业级落地实战：多级缓存全链路整合

6.1 方案一：Caffeine+Redis+Lettuce（高并发首选）

（1）全链路流程

• 查询流程： 本地缓存（Caffeine）→ 命中返回 → 未命中 → Redis（Lettuce）→ 命中返回（同步到本地缓存）→ 未命中 → 分布式锁（Redisson）→ 数据库 → 回写 Redis+ 本地缓存 → 返回；
• 更新流程： 数据库更新 → 删除本地缓存 → Redis 删除（Lettuce）→ 延迟双删（线程池）→ 返回。

（2）实战代码（商品查询示例）

import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.UUID;

@Service
public class ProductService {
    @Resource
    private LocalCacheService localCacheService;
    @Resource
    private RedisLettuceCacheService lettuceCacheService;
    @Resource
    private RedissonLockUtil redissonLockUtil;
    @Resource
    private ProductDAO productDAO; // 数据库 DAO（MyBatis/MyBatis-Plus）

    /** * 商品查询（高并发全链路缓存逻辑） */
    public ProductDTO getProductById(Long productId) {
        if (productId == null || productId <= 0) {
            return null;
        }
        String cacheKey = "product:" + productId;
        ProductDTO productDTO;

        // 1. 查询本地缓存（Caffeine）
        productDTO = (ProductDTO) localCacheService.get(cacheKey);
        if (productDTO != null) {
            System.out.printf("本地缓存命中：key=%s%n", cacheKey);
            return productDTO;
        }

        // 2. 查询 Redis 缓存（Lettuce）
        productDTO = (ProductDTO) lettuceCacheService.get(cacheKey);
        if (productDTO != null) {
            // 同步到本地缓存
            localCacheService.put(cacheKey, productDTO);
            System.out.printf("Redis 缓存命中：key=%s%n", cacheKey);
            return productDTO;
        }

        // 3. 缓存未命中，加分布式锁防击穿（Redisson）
        String lockKey = "product:lock:" + productId;
        RLock lock = redissonLockUtil.tryLock(lockKey);
        if (lock == null) {
            // 未获取到锁，返回默认值或降级处理
            return null;
        }
        try {
            // 4. 再次查询 Redis（避免锁等待期间已被其他线程写入）
            productDTO = (ProductDTO) lettuceCacheService.get(cacheKey);
            if (productDTO != null) {
                localCacheService.put(cacheKey, productDTO);
                return productDTO;
            }

            // 5. 查询数据库
            productDTO = productDAO.selectById(productId);
            if (productDTO != null) {
                // 热点数据延长过期时间（3 小时）
                long expireSeconds = CacheConstants.DISTRIBUTED_CACHE_HOT_EXPIRE_SECONDS;
                // 回写 Redis+ 本地缓存
                lettuceCacheService.put(cacheKey, productDTO, expireSeconds);
                localCacheService.put(cacheKey, productDTO, CacheConstants.LOCAL_CACHE_HOT_EXPIRE_SECONDS);
            } else {
                // 数据库无结果，写入空值缓存（防穿透）
                lettuceCacheService.putNullValue(cacheKey);
                localCacheService.put(cacheKey, new RedisLettuceCacheService.NullValue());
            }
        } finally {
            // 释放锁
            redissonLockUtil.unlock(lock);
        }
        return productDTO;
    }

    /** * 商品更新（缓存同步流程） */
    public boolean updateProduct(ProductDTO productDTO) {
        if (productDTO == null || productDTO.getId() == null) {
            return false;
        }
        String cacheKey = "product:" + productDTO.getId();
        try {
            // 1. 先更新数据库
            boolean success = productDAO.update(productDTO);
            if (!success) {
                return false;
            }
            // 2. 删除本地缓存
            localCacheService.remove(cacheKey);
            // 3. 删除 Redis 缓存 + 延迟双删
            lettuceCacheService.delayDoubleRemove(cacheKey);
            return true;
        } catch (Exception e) {
            System.err.printf("更新商品异常：id=%s，异常=%s%n", productDTO.getId(), e.getMessage());
            return false;
        }
    }
}

6.2 方案二：Caffeine+Redisson（快速开发首选）

（1）全链路流程

• 查询流程：本地缓存（Caffeine）→ 命中返回 → 未命中 → Redisson 分布式 Map → 命中返回（同步到本地缓存）→ 未命中 → Redisson 分布式锁 → 数据库 → 回写双缓存 → 返回；
• 更新流程：数据库更新 → 删除本地缓存 → Redisson 分布式 Map 删除 → Redisson 延迟队列二次删除 → 返回。

（2）实战代码（简化版商品查询）

import org.redisson.api.RLock;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

@Service
public class ProductRedissonService {
    @Resource
    private LocalCacheService localCacheService;
    @Resource
    private RedissonCacheService redissonCacheService;
    @Resource
    private RedissonLockUtil redissonLockUtil;
    @Resource
    private ProductDAO productDAO;

    public ProductDTO getProductById(Long productId) {
        if (productId == null || productId <= 0) {
            return null;
        }
        String cacheKey = "product:" + productId;
        ProductDTO productDTO;

        // 1. 本地缓存查询
        productDTO = (ProductDTO) localCacheService.get(cacheKey);
        if (productDTO != null) {
            return productDTO;
        }

        // 2. Redisson 缓存查询
        productDTO = (ProductDTO) redissonCacheService.get(cacheKey);
        if (productDTO != null) {
            localCacheService.put(cacheKey, productDTO);
            return productDTO;
        }

        // 3. 分布式锁防击穿
        RLock lock = redissonLockUtil.tryLock(cacheKey);
        if (lock == null) {
            return null;
        }
        try {
            productDTO = (ProductDTO) redissonCacheService.get(cacheKey);
            if (productDTO != null) {
                localCacheService.put(cacheKey, productDTO);
                return productDTO;
            }

            // 4. 数据库查询 + 回写缓存
            productDTO = productDAO.selectById(productId);
            if (productDTO != null) {
                redissonCacheService.put(cacheKey, productDTO, CacheConstants.DISTRIBUTED_CACHE_HOT_EXPIRE_SECONDS);
                localCacheService.put(cacheKey, productDTO, CacheConstants.LOCAL_CACHE_HOT_EXPIRE_SECONDS);
            } else {
                redissonCacheService.putNullValue(cacheKey);
                localCacheService.put(cacheKey, new RedissonCacheService.NullValue());
            }
        } finally {
            redissonLockUtil.unlock(lock);
        }
        return productDTO;
    }
}

6.3 缓存三大问题解决方案落地（分方案）

七、总结与下一篇预告

7.1 核心收获

本文围绕'Java 工业级多级缓存'，落地了三大技术方案，核心收获如下：

1. 掌握本地缓存（Caffeine）的工业级配置与封装，理解其'高性能、低开销'的核心优势；
2. 精通 Redis 原生客户端（Lettuce/Jedis）的实现细节，明确 Lettuce 的首选地位与 Jedis 的备用场景；
3. 学会 Redisson 的核心用法，利用其分布式锁、延迟队列等高级功能解决缓存击穿、同步延迟等痛点；
4. 明确不同场景的选型逻辑，能根据并发量、功能需求快速选择最优方案，并实现全链路整合；
5. 解决缓存三大经典问题，形成'参数校验 + 空值缓存 + 分布式锁 + 过期随机化'的基础防护体系。

7.2 下一篇预告

本文的空值缓存方案在'海量无效 Key 场景'下存在明显局限：

• 大量空值缓存占用 Redis 宝贵内存；
• 空值缓存存在'过期窗口'，窗口期内的无效请求仍会穿透到数据库。

下一篇《Java 工业级缓存实战系列（二）：缓存穿透终极解决方案——布隆过滤器（Redisson+Redis Bloom）》将聚焦：

1. 布隆过滤器核心原理（二进制向量 + 多哈希函数）；
2. 双方案落地：Redisson 布隆过滤器（快速开发）与 Redis Bloom+Lettuce（极致性能）；
3. 布隆过滤器与本文多级缓存架构的无缝整合，形成'布隆拦截 + 空值缓存 + 多级缓存'的三重防护体系。

7.3 实战扩展建议

1. 序列化统一：所有方案统一使用 Fastjson2 或 Jackson，避免不同客户端序列化不一致导致的脏数据；
2. 动态配置：将缓存容量、过期时间、连接池参数等配置到 Nacos/Apollo，支持动态调整，无需重启应用；
3. 监控告警：接入 Prometheus+Grafana，监控缓存命中率（目标≥90%）、Redis 内存使用率（阈值≤70%）、分布式锁竞争率，设置告警阈值；
4. 压测验证：针对高并发场景做压测，验证 Lettuce 连接池参数、Redisson 锁性能，提前发现瓶颈；
5. 缓存预热：应用启动时，通过 CommandLineRunner 批量加载热点数据到 Caffeine+Redis，避免冷启动穿透。