Redis基于StringRedisTemplate实现缓存热点数据的实战教学

/** 签约客户清单缓存key. */
private static final String SIGNED_CUSTOMERS_CACHE_KEY = "sourcing-exchange-signed-customers";

/** 缓存过期时间,1小时. */
private static final long SIGNED_CUSTOMERS_CACHE_HOURS = 1;

// 1. 优先从 Redis 读
try {
    String cachedJson = stringRedisTemplate.opsForValue().get(SIGNED_CUSTOMERS_CACHE_KEY);
    if (cachedJson != null) {
        List<ExchangeContractCustomerDto> cachedList = StringUtil.parseJsonString(
            cachedJson, new TypeReference<List<ExchangeContractCustomerDto>>() {});
        if (cachedList != null) {
            return cachedList;             // 命中,直接返回
        }
    }
} catch (Exception e) {
    log.warn("读取缓存异常, 继续查询外部接口", e);   // 缓存故障不阻断主流程
}

// 2. 未命中:查数据源(分页拉外部接口 + 回查 DB)
Set<String> customerCodeSet = fetchAllSignedCustomerCodes();
List<ExchangeContractCustomerDto> resultList = buildCustomerDtoList(customerCodeSet);

// 3. 回写缓存
cacheSignedCustomers(resultList);
return resultList;

private void cacheSignedCustomers(List<ExchangeContractCustomerDto> resultList) {
    try {
        String json = StringUtil.getJsonString(resultList);        // 对象 → JSON
        stringRedisTemplate.opsForValue().set(
            SIGNED_CUSTOMERS_CACHE_KEY, json,
            SIGNED_CUSTOMERS_CACHE_HOURS, TimeUnit.HOURS);         // 带 TTL 写入
    } catch (Exception e) {
        log.warn("写入缓存异常", e);    // 写缓存失败仅告警,数据照常返回
    }
}

@Override
public void clearSignedCustomersCache() {
    try {
        Boolean deleted = stringRedisTemplate.delete(SIGNED_CUSTOMERS_CACHE_KEY);
        log.info("清除缓存, key={}, deleted={}", SIGNED_CUSTOMERS_CACHE_KEY, deleted);
    } catch (Exception e) {
        log.error("清除缓存异常", e);
        throw new JshServerException("清除签约客户缓存失败");
    }
}

@Slf4j
@Service
public class GenericCacheService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /** 缓存 key(带业务前缀). */
    private static final String CACHE_KEY = "demo:hot-data";
    /** TTL. */
    private static final long CACHE_TTL = 1;
    private static final TimeUnit TTL_UNIT = TimeUnit.HOURS;

    /**
     * Cache-Aside 读取:先缓存,未命中查数据源并回写.
     */
    public List<MyData> getData() {
        // 1. 读缓存(故障降级)
        try {
            String json = stringRedisTemplate.opsForValue().get(CACHE_KEY);
            if (json != null) {
                List<MyData> cached = parseJson(json);
                if (cached != null) {
                    return cached;
                }
            }
        } catch (Exception e) {
            log.warn("读缓存异常,降级查数据源", e);
        }

        // 2. 回源
        List<MyData> fresh = loadFromSource();   // 远程接口 / DB

        // 3. 回写缓存(失败不影响返回)
        writeCache(fresh);
        return fresh;
    }

    private void writeCache(List<MyData> data) {
        try {
            stringRedisTemplate.opsForValue()
                .set(CACHE_KEY, toJson(data), CACHE_TTL, TTL_UNIT);
        } catch (Exception e) {
            log.warn("写缓存异常", e);
        }
    }

    /** 主动清缓存:失败抛异常,让调用方感知. */
    public void evictCache() {
        try {
            Boolean deleted = stringRedisTemplate.delete(CACHE_KEY);
            log.info("清缓存, key={}, deleted={}", CACHE_KEY, deleted);
        } catch (Exception e) {
            log.error("清缓存异常", e);
            throw new RuntimeException("清缓存失败");
        }
    }

    // --- 省略 parseJson / toJson / loadFromSource 实现 ---
}