1. 项目背景与核心需求

烘焙坊电商平台的后端系统在用户量达到日均1万UV后，开始面临明显的性能瓶颈。特别是在促销活动期间，商品详情页的数据库查询QPS峰值突破800次/秒，导致MySQL实例CPU持续保持在90%以上。同时，购物车功能的并发写入冲突问题，使得部分用户在高峰期出现数据丢失情况。

这个阶段我们需要解决两个核心问题：

1. 高频访问数据的读取性能优化
2. 购物车这类写密集场景的数据一致性保障

缓存系统的引入成为必然选择。但具体实施方案需要权衡多个因素：缓存穿透的风险、数据一致性的保证、缓存层级的划分等。我们的技术选型最终确定为Redis作为主要缓存介质，配合本地Caffeine缓存构成二级缓存体系。

2. 缓存架构设计与实现

2.1 多级缓存方案选型

经过压力测试对比，我们最终采用的分层缓存结构如下：

这种架构的优势在于：

• 本地缓存解决超热点数据访问的极致性能需求
• Redis作为分布式缓存保证数据一致性
• 通过合理的过期策略平衡性能与数据准确性

2.2 Redis数据结构设计

针对不同业务场景，我们设计了差异化的数据结构：

商品信息缓存

// Key设计 String productKey = "product:" + productId + ":v" + version; // Value结构采用Hash存储 Map<String, String> productMap = new HashMap<>(); productMap.put("name", product.getName()); productMap.put("price", product.getPrice().toString()); productMap.put("stock", String.valueOf(product.getStock())); redisTemplate.opsForHash().putAll(productKey, productMap);

购物车缓存

// 使用Hash结构存储用户购物车 String cartKey = "cart:" + userId; redisTemplate.opsForHash().put( cartKey, productId.toString(), JSON.toJSONString(cartItem) ); // 设置合理的TTL（7天） redisTemplate.expire(cartKey, 7, TimeUnit.DAYS);

2.3 缓存一致性保障

我们采用"先更新数据库再删除缓存"的策略，配合消息队列实现最终一致性：

@Transactional public void updateProduct(Product product) { // 1. 更新数据库 productMapper.updateById(product); // 2. 发送缓存删除事件 String cacheKey = "product:" + product.getId(); rabbitTemplate.convertAndSend( "cache.events", new CacheEvictMessage(cacheKey) ); } // 消费者端处理 @RabbitListener(queues = "cache.queue") public void handleCacheEvict(CacheEvictMessage message) { try { redisTemplate.delete(message.getKey()); localCache.invalidate(message.getKey()); } catch (Exception e) { // 失败重试逻辑 retryTemplate.execute(context -> { redisTemplate.delete(message.getKey()); return null; }); } }

关键提示：在分布式环境下，即使这样仍然可能出现短暂的数据不一致。对于商品价格等关键数据，我们额外增加了版本号校验机制。

3. 购物车功能深度实现

3.1 并发写入解决方案

购物车面临的核心挑战是并发修改问题。我们采用Redis的HASH结构配合Lua脚本实现原子化操作：

-- cart_update.lua local userId = KEYS[1] local productId = KEYS[2] local quantity = tonumber(ARGV[1]) local maxLimit = tonumber(ARGV[2]) -- 获取当前数量 local current = redis.call('HGET', 'cart:'..userId, productId) local currentQty = current and tonumber(cjson.decode(current).quantity) or 0 -- 校验并更新 local newQty = currentQty + quantity if newQty <= 0 then redis.call('HDEL', 'cart:'..userId, productId) return 0 elseif newQty > maxLimit then return -1 else local item = { productId = productId, quantity = newQty, updatedAt = os.time() } redis.call('HSET', 'cart:'..userId, productId, cjson.encode(item)) return newQty end

Java调用方式：

Long result = redisTemplate.execute( new DefaultRedisScript<>(luaScript, Long.class), Arrays.asList(userId.toString(), productId.toString()), String.valueOf(changeQuantity), String.valueOf(MAX_CART_ITEMS) );

3.2 购物车过期策略

购物车数据的过期管理采用分层策略：

1. 基础TTL：所有购物车Key默认7天过期
2. 访问续期：每次读写操作时延长TTL
3. 定期清理：每周执行一次扫描，清理超过30天未更新的购物车

// 读写时续期示例 public CartItem getCartItem(Long userId, Long productId) { String cartKey = "cart:" + userId; String itemJson = (String) redisTemplate.opsForHash().get(cartKey, productId.toString()); // 续期操作 redisTemplate.expire(cartKey, 7, TimeUnit.DAYS); return parseCartItem(itemJson); }

3.3 购物车与库存的预扣减

在秒杀场景下，我们实现了购物车到订单的平滑过渡：

public boolean reserveInventory(Long userId, List<CartItem> items) { // 使用Redis的WATCH/MULTI实现乐观锁 return redisTemplate.execute(new SessionCallback<Boolean>() { @Override public Boolean execute(RedisOperations operations) throws DataAccessException { try { operations.watch(items.stream() .map(i -> "product:" + i.getProductId()) .toArray(String[]::new)); // 检查库存 Map<String, Integer> stocks = new HashMap<>(); for (CartItem item : items) { String key = "product:" + item.getProductId(); Integer stock = (Integer) operations.opsForHash().get(key, "stock"); if (stock == null || stock < item.getQuantity()) { operations.unwatch(); return false; } stocks.put(key, stock - item.getQuantity()); } // 扣减库存 operations.multi(); stocks.forEach((key, value) -> { operations.opsForHash().put(key, "stock", value.toString()); }); operations.exec(); return true; } catch (Exception e) { operations.discard(); throw e; } } }); }

4. 性能优化与问题排查

4.1 缓存穿透防护方案

针对商品详情页的缓存穿透问题，我们实现了多级防护：

1. 布隆过滤器前置校验
2. 空值缓存（缓存null值，设置短TTL）
3. 互斥锁重建缓存

public Product getProductWithCache(Long productId) { // 1. 布隆过滤器检查 if (!bloomFilter.mightContain(productId)) { return null; } // 2. 尝试从缓存获取 String cacheKey = "product:" + productId; Product product = cacheService.get(cacheKey); if (product != null) { return product instanceof NullProduct ? null : product; } // 3. 获取分布式锁 String lockKey = "lock:product:" + productId; try { boolean locked = redisLock.tryLock(lockKey, 3, TimeUnit.SECONDS); if (!locked) { // 短暂等待后重试 Thread.sleep(100); return getProductWithCache(productId); } // 4. 二次检查缓存（防止并发重复查询） product = cacheService.get(cacheKey); if (product != null) { return product instanceof NullProduct ? null : product; } // 5. 查询数据库 product = productMapper.selectById(productId); // 6. 写入缓存 if (product == null) { cacheService.put(cacheKey, new NullProduct(), 1, TimeUnit.MINUTES); } else { cacheService.put(cacheKey, product, 30, TimeUnit.MINUTES); } return product; } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException("Interrupted while getting product", e); } finally { redisLock.unlock(lockKey); } }

4.2 热点Key发现与处理

我们开发了实时热点监控系统，主要流程包括：

1. Redis监控数据采集（使用MONITOR命令采样）
2. 滑动窗口统计（5分钟窗口，1分钟滑动）
3. 热点Key自动识别（超过阈值自动报警）
4. 动态负载均衡（对热点Key进行本地缓存）

// 热点Key监控示例 public class HotKeyDetector { private final Map<String, AtomicLong> counterMap = new ConcurrentHashMap<>(); private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); public void start() { scheduler.scheduleAtFixedRate(this::analyzeHotKeys, 1, 1, TimeUnit.MINUTES); // 订阅Redis的MONITOR命令输出 redisTemplate.execute(new RedisCallback<Void>() { @Override public Void doInRedis(RedisConnection connection) throws DataAccessException { connection.monitor(new MessageListener() { @Override public void onMessage(Message message) { String cmd = new String(message.getBody()); if (cmd.startsWith("GET ") || cmd.startsWith("HGET ")) { String[] parts = cmd.split(" "); if (parts.length >= 2) { String key = parts[1]; counterMap.computeIfAbsent(key, k -> new AtomicLong()).incrementAndGet(); } } } }); return null; } }); } private void analyzeHotKeys() { long threshold = 1000; // 每分钟1000次访问 List<String> hotKeys = counterMap.entrySet().stream() .filter(e -> e.getValue().get() > threshold) .map(Map.Entry::getKey) .collect(Collectors.toList()); if (!hotKeys.isEmpty()) { alertAndHandleHotKeys(hotKeys); } counterMap.clear(); } }

4.3 典型问题排查记录

问题1：缓存雪崩导致服务不可用

• 现象：凌晨3点Redis连接数暴增，大量请求直接打到数据库
• 原因分析：多个重要Key设置了相同的过期时间，同时失效
• 解决方案：
  1. 对基础数据缓存设置随机过期时间（基础时间±随机偏移）
  2. 实现缓存预热定时任务
  3. 增加熔断降级机制

问题2：购物车数据偶尔丢失

• 现象：部分用户反映购物车商品突然清空
• 原因追踪：Redis内存达到maxmemory触发自动淘汰
• 解决方案：
  1. 调整Redis内存淘汰策略为volatile-lru
  2. 对购物车Key设置明确的TTL
  3. 增加Redis内存监控告警

问题3：高并发下库存超卖

• 现象：秒杀活动出现库存减为负数
• 根本原因：Redis与数据库库存不一致
• 最终方案：
  1. 引入分布式锁控制库存扣减
  2. 实现库存扣减的幂等操作
  3. 增加库存校验的异步对账任务

5. 监控与运维实践

5.1 关键指标监控体系

我们建立了完整的缓存监控看板，核心指标包括：

5.2 缓存治理策略

1. 定期扫描与清理

public void cleanExpiredCaches() { // 使用SCAN命令避免阻塞 String pattern = "product:*"; Cursor<byte[]> cursor = redisTemplate.scan( ScanOptions.scanOptions().match(pattern).count(100).build()); int cleaned = 0; while (cursor.hasNext()) { byte[] key = cursor.next(); if (redisTemplate.getExpire(key) == -1) { // 没有设置TTL的Key redisTemplate.expire(key, 24, TimeUnit.HOURS); cleaned++; } } logger.info("Cleaned {} caches without TTL", cleaned); }

2. 大Key分析与优化

• 使用redis-rdb-tools定期分析RDB文件
• 对超过10KB的Hash进行分片存储
• 对超过1MB的String类型数据转为Hash存储

3. 热Key自动迁移

• 实时监控热点Key分布
• 对极端热点Key启用本地缓存
• 使用Redis Cluster的迁移命令平衡负载

在实际运行中，这套缓存系统成功将商品详情页的P99响应时间从320ms降低到45ms，购物车操作的并发处理能力提升了8倍。特别是在618大促期间，系统平稳支撑了平时5倍的流量高峰。