Redis缓存落地总结

最近在优化电子签系统，涉及到缓存相关的也一并优化了，写个文档做个总结，防止以后开发时又考虑不全

1、避免大key

避免缓存大PDF文件：
💡 经验值：单个Redis Value不超过10KB，集合元素不超过5000个

// 反例：直接缓存整个PDF
@Cacheable(value = "contract_pdf", key = "#contractId")
public byte[] getContractPdf(String contractId) { /* 返回5MB文件 */ }

// 正例：拆分为元数据+文件存储
@Cacheable(value = "contract_meta", key = "#contractId")
public ContractMeta getContractMeta(String contractId) { /* 返回1KB元数据 */ }

public byte[] getContractPdf(String fileResId) {
    // 从对象存储按需获取
    return fileStoreUtil.getFileByResId(fileResId); 
}

不是不能缓存大数据，而是避免用缓存替代存储系统，需要根据数据访问频率、读写比例、数据一致性要求进行分级管理。大对象缓存会导致内存碎片化，甚至触发Full GC。

2、动态TTL策略

问题场景还原
合同模板缓存的TTL固定为1小时，导致：
法律风险：法务紧急更新模板后，旧版本缓存未及时失效
穿透风险：缓存过期，引发批量缓存穿透

解决方案：三级TTL策略

// 合同模板缓存设置（Spring Boot实现）
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
    return RedisCacheManager.builder(factory)
        // 基础TTL + 随机抖动（防集中失效）
        .cacheDefaults(defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30 + ThreadLocalRandom.current().nextInt(10)))
        )
        // 特殊Key定制（高敏感数据缩短TTL）
        .withInitialCacheConfigurations(Map.of(
            "contract_template", CacheConfig.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(5)) // 模板变更频繁
        ))
        .build();
}

// 获取模板时动态续期（高频访问数据自动延长有效期）
public String getContractTemplate(String templateId) {
    String template = redisTemplate.opsForValue().get(templateId);
    if (template != null) {
        // 每次访问续期15分钟（LFU思想）
        redisTemplate.expire(templateId, 15, TimeUnit.MINUTES); 
    }
    return template;
}

3、避免批量失效

血泪教训
项目压测期间，积分缓存设置相同TTL，导致凌晨集中失效，数据库瞬时被打爆

数据库瞬时QPS飙升：从2000飙升至12000+
线程池满载：大量查询堆积触发熔断

// 缓存加载时注入随机TTL（单位：秒）
public void cacheElectricData(String plantId, ElectricData data) {
    // 基础24小时 + 随机2小时分钟（3600 * 24 ± 3600 * 2秒）
    int baseTtl = 3600 * 24; 
    int randomOffset = new Random().nextInt(3600 * 2); 
    redisTemplate.opsForValue().set(
        "plant_electric:" + plantId, 
        data, 
        baseTtl + randomOffset, 
        TimeUnit.SECONDS
    );
}

失效时间均匀分布在 02:00~04:00（业务低谷）

4、增加熔断降级

防止万一缓存挂了，不能影响整个服务的可用性

这个就不仅仅是缓存了，例如合同签署过程中，CA机构服务异常，不能阻塞后续业务进行

// 1. 框架层熔断（Sentinel）
@SentinelResource(
    value = "caSignService", 
    fallback = "localFallback", 
    blockHandler = "systemBlock",
    exceptionsToIgnore = {InvalidSignatureException.class} // 业务异常不触发熔断
)
public SignResult callCaService(Certificate cert, byte[] pdf) {
    return caClient.sign(cert, pdf); // CA机构远程调用
}

// 2. 降级策略 - 本地存证+异步补偿
private SignResult localFallback(Certificate cert, byte[] pdf, Throwable ex) {
    // 生成临时签名标识（法律允许72小时内补签）
    String tempSignId = "TEMP_" + UUID.randomUUID();
    
    // 存储待签文件至MinIO
    minioClient.putObject("pending-sign", tempSignId, pdf);
    
    // 发送延迟补偿消息（每5分钟重试）
    rocketMQTemplate.sendDelay("SIGN_RETRY_TOPIC", 
        MessageBuilder.withPayload(tempSignId).build(),
        5, TimeUnit.MINUTES);
    
    return new SignResult(202, "签名延迟处理中", tempSignId);
}

// 3. 系统级熔断 - 返回法律兜底模板
private SignResult systemBlock(Certificate cert, byte[] pdf, BlockException ex) {
    return new SignResult(503, "系统维护中，请使用纸质签约流程");
}

5、空值缓存

在用户请求并发量大的业务场景种，需要把空值缓存起来，防止大批量在系统中不存在的id，没有命中缓存，而直接查询数据库的情况。

测评时遇到非法合同ID扫描攻击

需记录审计日志
防止缓存污染

分层拦截方案

public Contract getContract(String contractId) {
    // 第一层：布隆过滤器（10亿数据占120MB）
    if (!bloomFilter.mightContain(contractId)) {
        auditService.logInvalidRequest(contractId); // 记录黑产行为
        throw new ContractNotFoundException();
    }
    
    // 第二层：空值缓存（带法律标识）
    Contract contract = redisTemplate.opsForValue().get(contractId);
    if (contract == NULL_LEGAL_OBJ) { // 特殊空值对象
        return null;
    }
    if (contract != null) {
        return contract;
    }
    
    // 第三层：分布式锁保护DB查询
    RLock lock = redisson.getLock("LOCK_CONTRACT:" + contractId);
    lock.lock(3, TimeUnit.SECONDS);
    try {
        // 双重检查
        contract = redisTemplate.get(contractId);
        if (contract != null) return contract;
        
        // 数据库查询
        contract = contractDao.findById(contractId);
        if (contract == null) {
            // 法律合规空值（带审计标记）
            LegalNullObject nullObj = new LegalNullObject(
                "INVALID_CONTRACT", 
                System.currentTimeMillis()
            );
            redisTemplate.opsForValue().set(
                contractId, 
                nullObj, 
                30, TimeUnit.SECONDS // 短TTL
            );
            return null;
        } else {
            redisTemplate.opsForValue().set(
                contractId, 
                contract, 
                1, TimeUnit.HOURS
            );
            return contract;
        }
    } finally {
        lock.unlock();
    }
}

6、分布式锁用Redisson

签章流水号控制，防止同一份合同被重复签署

红锁(RedLock)实现

public boolean trySignContract(String contractId) {
    // 获取5个独立Redis节点的锁
    RLock[] locks = new RLock[5];
    for (int i = 0; i < 5; i++) {
        locks[i] = redissonClient.getLock("SIGN_LOCK:" + contractId + ":node" + i);
    }
    RLock redLock = new RedissonRedLock(locks);
    
    try {
        // 尝试加锁（等待300ms，锁持有1分钟）
        if (redLock.tryLock(300, 60_000, TimeUnit.MILLISECONDS)) {
            if (signLogDao.hasSigned(contractId)) {
                return false; // 已签署
            }
            caService.sign(contractId);
            return true;
        }
        return false;
    } finally {
        redLock.unlock();
    }
}

7、延迟双删策略

签署任务状态一致性保障

签署任务状态变更后必须确保缓存与数据库绝对一致

// 四阶段双删策略
@Transactional
public void updateContractStatus(String contractId, ContractStatus status) {
    // 阶段1：预删除缓存
    redisTemplate.delete(contractId);
    
    // 阶段2：DB更新（带事务）
    contractDao.updateStatus(contractId, status);
    
    // 阶段3：异步延迟双删
    rocketMQTemplate.sendAsync("CACHE_DELETE_TOPIC", 
        MessageBuilder.withPayload(contractId)
            .setHeader("DELAY_LEVEL", "3") // 5秒延迟
            .build()
    );
    
    // 阶段4：区块链存证（独立事务）
    blockchainService.recordStatusChange(contractId, status);
}

// MQ消费者
@RocketMQMessageListener(topic = "CACHE_DELETE_TOPIC")
public class CacheDeleteListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String contractId) {
        // 二次删除
        redisTemplate.delete(contractId);
        
        // 重建缓存（最终一致性）
        Contract contract = contractDao.findById(contractId);
        if (contract != null) {
            redisTemplate.opsForValue().set(
                contractId, 
                contract, 
                1, TimeUnit.HOURS
            );
        }
    }
}

8、最终一致性方案

// 1. 可靠消息发送（防丢失）
public void updateContractStatus(String contractId, Status status) {
    // 在事务中保存状态变更记录
    contractDao.updateStatus(contractId, status); 
    
    // 发送半消息（RocketMQ事务消息）
    TransactionSendResult sendResult = rocketMQTemplate.sendMessageInTransaction(
        "contract_tx_group",
        MessageBuilder.withPayload(new StatusChangeEvent(contractId, status)).build(),
        null
    );
    
    // 事务回查（确保消息落地）
    if (sendResult.getState() != LocalTransactionState.COMMIT_MESSAGE) {
        throw new IllegalStateException("消息发送失败");
    }
}

// 2. MQ消费者（保证幂等）
@RocketMQMessageListener(topic = "STATUS_CHANGE_TOPIC", consumerGroup = "contract_group")
public class StatusChangeConsumer implements RocketMQListener<StatusChangeEvent> {
    @Override
    public void onMessage(StatusChangeEvent event) {
        // 幂等检查（防止重复消费）
        if (statusLogDao.isProcessed(event.getMessageId())) return;
        
        // 步骤1：删除缓存
        redisTemplate.delete("contract:" + event.getContractId());
        
        // 步骤2：区块链存证
        blockchainService.recordStatus(event.getContractId(), event.getStatus());
        
        // 步骤3：重建缓存（存证成功后）
        Contract contract = contractDao.findById(event.getContractId());
        redisTemplate.opsForValue().set(
            "contract:" + event.getContractId(), 
            contract,
            1, TimeUnit.HOURS
        );
        
        // 记录处理日志
        statusLogDao.markProcessed(event.getMessageId());
    }
}

9、热点数据预加载

合同模板缓存

上班时间（9:00）模板请求量激增
新模板上线时缓存穿透

// 1. 基于时间窗口的预测加载
@Scheduled(cron = "0 0 8 * * ?") // 每天8:00执行
public void preloadMorningTemplates() {
    // 预测今日热点（昨日TOP100模板）
    List<String> hotTemplates = statsDao.getYesterdayHotTemplates(100);
    
    // 并行预加载
    hotTemplates.parallelStream().forEach(templateId -> {
        ContractTemplate template = templateDao.load(templateId);
        redisTemplate.opsForValue().set(
            "template:" + templateId,
            template,
            12, TimeUnit.HOURS // 覆盖日间高峰
        );
    });
}

// 2. 实时热点探测（流式计算）
@KafkaListener(topics = "template_access_log")
public void handleAccessLog(AccessLog log) {
    // 滑动窗口计数（10分钟）
    long count = redisTemplate.opsForZSet().count(
        "template_access:" + log.templateId(), 
        System.currentTimeMillis() - 600_000, 
        Long.MAX_VALUE
    );
    
    // 超过阈值触发预加载
    if (count > 1000) { 
        executor.submit(() -> {
            if (!redisTemplate.hasKey("template:" + log.templateId())) {
                loadTemplateToCache(log.templateId());
            }
        });
    }
}

10、根据场景选择数据结构

错误案例

redis.set("template:123", JSON.toJSONString(template));

每次更新单个字段都需要反序列化整个对象。

导致问题：

序列化/反序列化开销大
更新单个字段需读写整个对象
内存占用高正确实践：

正确案例

// 使用Hash存储  
redis.opsForHash().putAll("template:123", templateToMap(template));  

// 局部更新  
redis.opsForHash().put("template:123", "resId", "31212");