Spring Cloud 商品服务核心实现：库存、缓存与分布式锁

3. 环境搭建：Spring Cloud 商品服务初始化与基础配置

3.1 项目初始化

创建 Spring Boot 项目（命名为 product-service），引入核心依赖，pom.xml 关键配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>product-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>product-service</name>
    <!-- Spring Cloud Alibaba 依赖管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2023.0.1.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <!-- Spring Web 核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Cloud Alibaba Nacos 服务发现 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- MyBatis-Plus 数据持久层 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.5</version>
        </dependency>
        <!-- MySQL 驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- Redis 缓存 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- Redisson 分布式锁 -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.23.3</version>
        </dependency>
        <!-- Hutool 工具类 -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.20</version>
        </dependency>
        <!-- Lombok 简化实体类 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

3.2 基础配置

编写 application.yml 配置文件，配置数据库、Redis、Nacos、Redisson 等核心参数：

server:
  port: 8081 # 商品服务端口
spring:
  application:
    name: product-service # 服务名称（Nacos 注册用）
  # 数据库配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/product_service?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: root123456
  # Redis 配置
  redis:
    host: localhost
    port: 6379
    password: # 无密码则留空
    database: 0
    timeout: 3000ms
  # Nacos 服务注册发现配置
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos 服务地址
  # MyBatis-Plus 配置
  mybatis-plus:
    mapper-locations: classpath:mapper/*.xml # Mapper XML 文件路径
    type-aliases-package: com.example.productservice.entity # 实体类别名包
    configuration:
      map-underscore-to-camel-case: true # 下划线转驼峰
      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 开发环境打印 SQL
  # Redisson 配置（简化配置，生产环境可根据需求调整）
  redisson:
    singleServerConfig:
      address: redis://localhost:6379
      database: 0
      timeout: 3000ms

3.3 项目结构搭建

搭建清晰的项目目录结构，便于后续维护和扩展：

product-service/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── productservice/
│   │   │               ├── ProductServiceApplication.java # 启动类
│   │   │               ├── entity/ # 实体类（Product、Stock 等）
│   │   │               ├── mapper/ # Mapper 接口
│   │   │               ├── service/ # 业务层接口
│   │   │               │   └── impl/ # 业务层实现类
│   │   │               ├── controller/ # 控制层接口
│   │   │               ├── config/ # 配置类（Redis、Redisson、MyBatis-Plus 等）
│   │   │               ├── util/ # 工具类（缓存键生成、结果封装等）
│   │   │               └── exception/ # 异常处理（全局异常、库存不足异常等）
│   │   └── resources/
│   │       ├── mapper/ # Mapper XML 文件
│   │       ├── application.yml # 配置文件
│   │       └── db/ # 数据库脚本
│   └── test/ # 测试类
└── pom.xml # 依赖配置

4. 核心模块一：库存管理（精准扣减 + 防超卖）

库存管理是商品服务的核心，核心目标是确保库存数据精准，杜绝超卖。本文采用'数据库乐观锁'实现库存扣减，兼顾性能与数据一致性。

4.1 数据模型设计

设计 product（商品表）和 stock（库存表），将商品基础信息与库存数据分离，便于独立维护和扩展：

4.1.1 数据库脚本

创建 product_service 数据库，执行以下 SQL 脚本：

-- 商品表
CREATE TABLE `product` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '商品 ID',
  `product_name` varchar(100) NOT NULL COMMENT '商品名称',
  `price` decimal(10,2) NOT NULL COMMENT '商品价格',
  `spec` varchar(200) DEFAULT NULL COMMENT '商品规格',
  `status` tinyint(1) DEFAULT 1 COMMENT '状态：1-上架，0-下架',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品表';

-- 库存表（乐观锁字段 version）
CREATE TABLE `stock` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '库存 ID',
  `product_id` bigint(20) NOT NULL COMMENT '商品 ID（关联商品表）',
  `total_stock` int(11) NOT NULL DEFAULT 0 COMMENT '总库存',
  `lock_stock` int(11) NOT NULL DEFAULT 0 COMMENT '已锁定库存（未支付订单占用）',
  `available_stock` int(11) NOT NULL DEFAULT 0 COMMENT '可用库存（total_stock - lock_stock）',
  `version` int(11) NOT NULL DEFAULT 0 COMMENT '版本号（乐观锁用）',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_product_id` (`product_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='库存表';

4.1.2 实体类编写

编写 Product 和 Stock 实体类（使用 Lombok 简化代码）：

// Product 实体类
package com.example.productservice.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;

@Data
@TableName("product")
public class Product {
    /**
     * 商品 ID
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 商品名称
     */
    private String productName;

    /**
     * 商品价格
     */
    private BigDecimal price;

    /**
     * 商品规格
     */
    private String spec;

    /**
     * 状态：1-上架，0-下架
     */
    private Integer status;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
}

// Stock 实体类（含乐观锁版本号）
package com.example.productservice.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;
import java.time.LocalDateTime;

@Data
@TableName("stock")
public class Stock {
    /**
     * 库存 ID
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 商品 ID
     */
    private Long productId;

    /**
     * 总库存
     */
    private Integer totalStock;

    /**
     * 已锁定库存
     */
    private Integer lockStock;

    /**
     * 可用库存
     */
    private Integer availableStock;

    /**
     * 版本号（乐观锁用）
     */
    @Version
    private Integer version;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
}

4.2 库存核心操作实现

库存操作核心包括：查询库存、扣减库存（下单时）、解锁库存（订单取消时）、补增库存（退货时），重点实现扣减库存的防超卖逻辑。

4.2.1 数据层开发

编写 ProductMapper 和 StockMapper 接口，以及对应的 XML 文件：

// ProductMapper 接口
package com.example.productservice.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.productservice.entity.Product;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface ProductMapper extends BaseMapper<Product> {
}

// StockMapper 接口
package com.example.productservice.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.productservice.entity.Stock;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface StockMapper extends BaseMapper<Stock> {
    /**
     * 扣减库存（乐观锁实现）
     * @param productId 商品 ID
     * @param deductCount 扣减数量
     * @param version 版本号
     * @return 影响行数（1-成功，0-失败）
     */
    int deductStock(@Param("productId") Long productId, @Param("deductCount") Integer deductCount, @Param("version") Integer version);

    /**
     * 根据商品 ID 查询库存
     * @param productId 商品 ID
     * @return 库存信息
     */
    Stock selectStockByProductId(@Param("productId") Long productId);
}

编写 StockMapper.xml，实现库存扣减的 SQL（乐观锁核心）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.productservice.mapper.StockMapper">
    <!-- 扣减库存（乐观锁）：where 条件中增加 version 匹配，确保并发安全 -->
    <update>
        UPDATE stock 
        SET available_stock = available_stock - #{deductCount}, 
            lock_stock = lock_stock + #{deductCount}, 
            version = version + 1 
        WHERE product_id = #{productId} 
          AND available_stock >= #{deductCount} <!-- 确保可用库存足够 -->
          AND version = #{version} <!-- 乐观锁版本匹配 -->
    </update>
    <!-- 根据商品 ID 查询库存 -->
    <select resultType="com.example.productservice.entity.Stock">
        SELECT id, product_id, total_stock, lock_stock, available_stock, version, update_time 
        FROM stock 
        WHERE product_id = #{productId}
    </select>
</mapper>

4.2.2 业务层开发

编写 StockService 接口与实现类，封装库存核心操作，重点处理扣减库存的重试逻辑（乐观锁失败时重试）：

// StockService 接口
package com.example.productservice.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.productservice.entity.Stock;
import com.example.productservice.util.Result;

/**
 * 库存业务层接口
 */
public interface StockService extends IService<Stock> {
    /**
     * 扣减库存（下单时）
     * @param productId 商品 ID
     * @param deductCount 扣减数量
     * @return 扣减结果
     */
    Result<?> deductStock(Long productId, Integer deductCount);

    /**
     * 解锁库存（订单取消时）
     * @param productId 商品 ID
     * @param unlockCount 解锁数量
     * @return 解锁结果
     */
    Result<?> unlockStock(Long productId, Integer unlockCount);

    /**
     * 根据商品 ID 查询库存
     * @param productId 商品 ID
     * @return 库存信息
     */
    Result<Stock> getStockByProductId(Long productId);
}

// StockServiceImpl 实现类
package com.example.productservice.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.productservice.entity.Stock;
import com.example.productservice.mapper.StockMapper;
import com.example.productservice.service.StockService;
import com.example.productservice.util.Result;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * 库存业务层实现类
 */
@Service
public class StockServiceImpl extends ServiceImpl<StockMapper, Stock> implements StockService {
    @Resource
    private StockMapper stockMapper;

    /**
     * 扣减库存（乐观锁 + 重试机制）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> deductStock(Long productId, Integer deductCount) {
        // 校验参数
        if (productId == null || deductCount == null || deductCount <= 0) {
            return Result.fail("参数错误：商品 ID 不能为空，扣减数量必须大于 0");
        }

        // 乐观锁重试机制（最多重试 3 次，避免无限重试）
        int maxRetry = 3;
        int retryCount = 0;
        while (retryCount < maxRetry) {
            // 1. 查询当前库存（获取最新版本号）
            Stock stock = stockMapper.selectStockByProductId(productId);
            if (stock == null) {
                return Result.fail("商品库存不存在");
            }

            // 2. 校验可用库存是否足够
            if (stock.getAvailableStock() < deductCount) {
                return Result.fail("库存不足，当前可用库存：" + stock.getAvailableStock());
            }

            // 3. 扣减库存（乐观锁）
            int affectRows = stockMapper.deductStock(productId, deductCount, stock.getVersion());
            if (affectRows > 0) {
                // 扣减成功，返回结果
                return Result.success("库存扣减成功");
            }

            // 4. 扣减失败（并发冲突），重试
            retryCount++;
            if (retryCount >= maxRetry) {
                return Result.fail("库存扣减失败，请重试");
            }

            // 重试间隔（避免高频重试）
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return Result.fail("库存扣减异常");
            }
        }
        return Result.fail("库存扣减失败，请重试");
    }

    /**
     * 解锁库存（订单取消时）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> unlockStock(Long productId, Integer unlockCount) {
        // 校验参数
        if (productId == null || unlockCount == null || unlockCount <= 0) {
            return Result.fail("参数错误：商品 ID 不能为空，解锁数量必须大于 0");
        }

        // 查询库存
        Stock stock = stockMapper.selectStockByProductId(productId);
        if (stock == null) {
            return Result.fail("商品库存不存在");
        }

        // 校验锁定库存是否足够
        if (stock.getLockStock() < unlockCount) {
            return Result.fail("锁定库存不足，无法解锁");
        }

        // 解锁库存（锁定库存减少，可用库存增加）
        stock.setLockStock(stock.getLockStock() - unlockCount);
        stock.setAvailableStock(stock.getAvailableStock() + unlockCount);
        boolean updateResult = this.updateById(stock);
        return updateResult ? Result.success("库存解锁成功") : Result.fail("库存解锁失败");
    }

    /**
     * 根据商品 ID 查询库存
     */
    @Override
    public Result<Stock> getStockByProductId(Long productId) {
        if (productId == null) {
            return Result.fail("商品 ID 不能为空");
        }
        Stock stock = stockMapper.selectStockByProductId(productId);
        return stock != null ? Result.success(stock) : Result.fail("商品库存不存在");
    }
}

4.3 库存流转流程

库存流转的核心场景包括'下单扣减''订单取消解锁''订单支付确认''退货补增'，完整流程如下：

5. 核心模块二：缓存设计（穿透 + 击穿 + 雪崩解决方案）

商品查询是高并发场景的核心需求，直接查询数据库会导致数据库压力过大，因此需要引入 Redis 缓存。但缓存使用不当会引发'穿透、击穿、雪崩'三大问题，本文给出完整解决方案。

5.1 缓存核心流程

商品缓存的核心流程是'缓存优先查询'：

1. 客户端查询商品信息时，先查询 Redis 缓存；
2. 缓存命中：直接返回缓存数据；
3. 缓存未命中：查询数据库，将查询结果写入缓存，再返回数据；
4. 商品信息更新时，同步更新缓存（或删除缓存，由下次查询重建）。

完整缓存流程与问题解决方案如下：

5.2 缓存三大问题解决方案

5.2.1 缓存穿透（查询不存在的商品）

问题：恶意用户频繁查询不存在的商品 ID，缓存未命中，直接穿透到数据库，导致数据库压力激增。 解决方案：布隆过滤器（拦截不存在的商品 ID）+ 缓存空值（短期缓存不存在的商品结果）。

代码实现（布隆过滤器 + 缓存空值）：

// 缓存工具类（封装缓存空值与布隆过滤器逻辑）
package com.example.productservice.util;

import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.digest.BloomFilter;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Component
public class CacheUtil {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 布隆过滤器（预计插入 10 万条商品 ID，误判率 0.01%）
    private final BloomFilter<Long> productBloomFilter = BloomFilter.create(100000, 0.0001);

    /**
     * 初始化布隆过滤器（项目启动时加载所有商品 ID）
     * @param productIds 所有商品 ID 列表
     */
    public void initBloomFilter(Long... productIds) {
        for (Long productId : productIds) {
            productBloomFilter.add(productId);
        }
    }

    /**
     * 查询缓存（含防穿透处理）
     * @param key 缓存键
     * @param productId 商品 ID（用于布隆过滤器校验）
     * @return 缓存值（null 表示无缓存或商品不存在）
     */
    public String getCacheWithPenetrationProtection(String key, Long productId) {
        // 1. 布隆过滤器拦截不存在的商品 ID
        if (!productBloomFilter.contains(productId)) {
            return null;
        }

        // 2. 查询缓存
        String value = stringRedisTemplate.opsForValue().get(key);

        // 3. 缓存空值处理（避免再次穿透）
        if (StrUtil.isBlank(value)) {
            // 缓存空值，过期时间 1 分钟（短期）
            stringRedisTemplate.opsForValue().set(key, "", 1, TimeUnit.MINUTES);
            return null;
        }
        return value;
    }

    /**
     * 写入缓存（含防击穿处理：热点商品永不过期，非热点商品设置过期时间）
     * @param key 缓存键
     * @param value 缓存值
     * @param isHotProduct 是否热点商品
     * @param expireTime 过期时间（非热点商品用）
     * @param timeUnit 时间单位
     */
    public void setCacheWithBreakdownProtection(String key, String value, boolean isHotProduct, long expireTime, TimeUnit timeUnit) {
        if (isHotProduct) {
            // 热点商品：永不过期，通过后台定时任务更新
            stringRedisTemplate.opsForValue().set(key, value);
        } else {
            // 非热点商品：设置过期时间，同时添加随机值避免雪崩
            long randomExpire = expireTime + (long) (Math.random() * 300); // 增加 0-5 分钟随机过期
            stringRedisTemplate.opsForValue().set(key, value, randomExpire, timeUnit);
        }
    }

    /**
     * 删除缓存
     * @param key 缓存键
     */
    public void deleteCache(String key) {
        stringRedisTemplate.delete(key);
    }
}

5.2.2 缓存击穿（热点商品缓存过期）

问题：热点商品（如大促爆款）缓存过期瞬间，大量请求同时穿透到数据库，导致数据库压力激增。 解决方案：热点商品永不过期（后台定时更新）+ 非热点商品互斥锁（缓存过期时只允许一个线程查询数据库）。

代码实现（互斥锁）：

// 商品服务中添加缓存查询逻辑（含互斥锁）
package com.example.productservice.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.productservice.entity.Product;
import com.example.productservice.mapper.ProductMapper;
import com.example.productservice.service.ProductService;
import com.example.productservice.util.CacheUtil;
import com.example.productservice.util.Result;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 商品业务层实现类
 */
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
    @Resource
    private ProductMapper productMapper;

    @Resource
    private CacheUtil cacheUtil;

    @Resource
    private ObjectMapper objectMapper;

    // 本地互斥锁（非热点商品用，热点商品永不过期无需锁）
    private final Lock cacheLock = new ReentrantLock();

    /**
     * 根据商品 ID 查询商品信息（含缓存）
     */
    @Override
    public Result<Product> getProductById(Long productId) {
        if (productId == null) {
            return Result.fail("商品 ID 不能为空");
        }

        // 1. 定义缓存键
        String cacheKey = "product:info:" + productId;

        // 2. 查询缓存（含防穿透处理）
        String cacheValue = cacheUtil.getCacheWithPenetrationProtection(cacheKey, productId);
        if (StringUtils.hasText(cacheValue)) {
            // 缓存命中，解析返回
            try {
                Product product = objectMapper.readValue(cacheValue, Product.class);
                return Result.success(product);
            } catch (JsonProcessingException e) {
                // 缓存解析失败，删除缓存
                cacheUtil.deleteCache(cacheKey);
            }
        }

        // 3. 缓存未命中，获取互斥锁查询数据库
        Product product = null;
        try {
            // 尝试获取锁（500ms 超时）
            if (cacheLock.tryLock(500, TimeUnit.MILLISECONDS)) {
                // 再次查询缓存（避免锁等待期间其他线程已更新缓存）
                cacheValue = cacheUtil.getCacheWithPenetrationProtection(cacheKey, productId);
                if (StringUtils.hasText(cacheValue)) {
                    product = objectMapper.readValue(cacheValue, Product.class);
                    return Result.success(product);
                }

                // 4. 查询数据库
                product = productMapper.selectById(productId);
                if (product == null) {
                    return Result.fail("商品不存在");
                }

                // 5. 写入缓存（判断是否热点商品，这里简化为：ID<=100 的为热点商品）
                boolean isHotProduct = productId <= 100;
                cacheUtil.setCacheWithBreakdownProtection(
                        cacheKey,
                        objectMapper.writeValueAsString(product),
                        isHotProduct,
                        30, // 非热点商品过期时间 30 分钟
                        TimeUnit.MINUTES
                );
            } else {
                // 获取锁失败，返回重试提示
                return Result.fail("查询繁忙，请重试");
            }
        } catch (Exception e) {
            return Result.fail("查询商品异常：" + e.getMessage());
        } finally {
            // 释放锁
            if (cacheLock.isHeldByCurrentThread()) {
                cacheLock.unlock();
            }
        }
        return Result.success(product);
    }
}

5.2.3 缓存雪崩（大量缓存同时过期）

问题：大量商品缓存设置了相同的过期时间，到期时同时失效，导致大量请求穿透到数据库，引发服务雪崩。 解决方案：缓存过期时间添加随机值（分散过期时间）+ 缓存集群（避免单点故障）+ 服务降级熔断（保护数据库）。

代码实现（过期时间加随机值）：

在 CacheUtil 的 setCacheWithBreakdownProtection 方法中，已实现'过期时间加随机值'逻辑：

// 非热点商品：设置过期时间，同时添加随机值避免雪崩
long randomExpire = expireTime + (long) (Math.random() * 300); // 增加 0-5 分钟随机过期
stringRedisTemplate.opsForValue().set(key, value, randomExpire, timeUnit);

5.3 缓存一致性保障

商品信息更新时，需确保缓存与数据库数据一致，采用'先更新数据库，再删除缓存'的策略（适合读多写少的商品服务场景），避免'缓存脏数据'问题。

完整代码实现（商品更新 + 缓存删除）

@Override
@Transactional(rollbackFor = Exception.class)
public Result<?> updateProduct(Product product) {
    if (product.getId() == null) {
        return Result.fail("商品 ID 不能为空");
    }

    // 1. 更新数据库（先操作数据库，保证数据持久化）
    boolean updateResult = this.updateById(product);
    if (!updateResult) {
        return Result.fail("商品更新失败");
    }

    // 2. 删除缓存（后删除缓存，下次查询时重建缓存，保证数据一致性）
    String cacheKey = "product:info:" + product.getId();
    cacheUtil.deleteCache(cacheKey);
    return Result.success("商品更新成功");
}

缓存一致性补充说明

• 为何不先删缓存再更数据库：高并发场景下，若先删缓存，此时有查询请求穿透到数据库，获取旧数据并写入缓存，随后数据库更新为新数据，导致缓存中出现脏数据。
• 极端场景处理：若更新数据库成功后，删除缓存失败（如 Redis 宕机），可通过定时任务定期校验缓存与数据库数据一致性，修复脏数据。

6. 核心模块三：分布式锁（Redisson 实现）

在微服务集群部署场景下，本地锁（如 ReentrantLock）仅能控制单个服务实例的并发，无法跨服务实现库存扣减的并发安全。本文基于 Redisson 实现分布式锁，解决跨服务的并发控制问题。

6.1 分布式锁核心原理

Redisson 基于 Redis 实现分布式锁，核心采用 Redis 的 SETNX 命令（原子性操作），同时支持自动续期（解决锁超时释放问题）、可重入（同一线程可多次获取同一把锁）、公平锁（按请求顺序获取锁）等企业级特性。

分布式锁在库存扣减场景的工作流程如下：

6.2 Redisson 分布式锁核心配置

Redisson 已通过 Starter 集成，只需在 application.yml 中配置 Redis 连接信息（前文已配置），无需额外复杂配置。若需自定义锁参数（如默认超时时间），可添加如下配置：

redisson:
  singleServerConfig:
    address: redis://localhost:6379
    database: 0
    timeout: 3000ms
    lock:
      defaultLockWatchdogTimeout: 30000 # 锁自动续期时间，默认 30 秒

6.3 分布式锁 + 乐观锁 双重保障库存扣减

为进一步提升库存扣减的并发安全性，采用'分布式锁（跨服务并发控制） + 乐观锁（数据库层并发控制）'的双重保障策略，核心代码实现如下：

6.3.1 库存服务中集成 Redisson 分布式锁

修改 StockServiceImpl 的 deductStock 方法，添加分布式锁逻辑：

package com.example.productservice.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.productservice.entity.Stock;
import com.example.productservice.mapper.StockMapper;
import com.example.productservice.service.StockService;
import com.example.productservice.util.Result;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * 库存业务层实现类（集成分布式锁）
 */
@Service
public class StockServiceImpl extends ServiceImpl<StockMapper, Stock> implements StockService {
    @Resource
    private StockMapper stockMapper;

    @Resource
    private RedissonClient redissonClient;

    /**
     * 扣减库存（分布式锁 + 乐观锁 双重保障）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> deductStock(Long productId, Integer deductCount) {
        // 1. 校验参数
        if (productId == null || deductCount == null || deductCount <= 0) {
            return Result.fail("参数错误：商品 ID 不能为空，扣减数量必须大于 0");
        }

        // 2. 定义分布式锁键（按商品 ID 粒度加锁，避免全局锁）
        String lockKey = "stock:deduct:" + productId;
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 3. 获取分布式锁（最多等待 5 秒，锁自动续期，业务执行完手动释放）
            boolean lockAcquired = lock.tryLock(5, TimeUnit.SECONDS);
            if (!lockAcquired) {
                return Result.fail("系统繁忙，请稍后重试");
            }

            // 4. 乐观锁重试机制（分布式锁内的数据库层并发控制）
            int maxRetry = 3;
            int retryCount = 0;
            while (retryCount < maxRetry) {
                // 4.1 查询当前库存（获取最新版本号）
                Stock stock = stockMapper.selectStockByProductId(productId);
                if (stock == null) {
                    return Result.fail("商品库存不存在");
                }

                // 4.2 校验可用库存是否足够
                if (stock.getAvailableStock() < deductCount) {
                    return Result.fail("库存不足，当前可用库存：" + stock.getAvailableStock());
                }

                // 4.3 扣减库存（乐观锁）
                int affectRows = stockMapper.deductStock(productId, deductCount, stock.getVersion());
                if (affectRows > 0) {
                    // 扣减成功，返回结果
                    return Result.success("库存扣减成功");
                }

                // 4.4 扣减失败（并发冲突），重试
                retryCount++;
                if (retryCount >= maxRetry) {
                    return Result.fail("库存扣减失败，请重试");
                }

                // 重试间隔
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return Result.fail("库存扣减异常");
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Result.fail("获取锁异常，请稍后重试");
        } finally {
            // 5. 释放分布式锁（确保锁最终释放，避免死锁）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        return Result.fail("库存扣减失败，请重试");
    }

    // 其他方法（unlockStock、getStockByProductId）保持不变
}

6.3.2 分布式锁核心设计要点

1. 锁粒度：按商品 ID 粒度加锁（lockKey = "stock:deduct:" + productId），避免使用全局锁，提升并发性能。
2. 锁等待：使用 tryLock(5, TimeUnit.SECONDS) 设置最大等待时间，避免用户无限等待。
3. 自动续期：Redisson 分布式锁默认开启自动续期（defaultLockWatchdogTimeout），解决长耗时业务导致锁超时释放的问题。
4. 锁释放：在 finally 块中释放锁，确保无论业务执行成功与否，锁最终都会被释放，避免死锁。

7. 实战测试：高并发场景下的功能与性能验证

通过 JMeter 模拟高并发场景，验证商品服务的库存防超卖、缓存有效性、分布式锁并发控制三大核心功能，测试流程如下：

7.1 测试环境准备

1. 基础数据：添加商品（ID=1，名称='测试商品'，价格=99.9），初始化库存（总库存=1000，可用库存=1000，锁定库存=0）。
2. JMeter 配置：创建线程组（线程数=1000，循环次数=1，Ramp-Up 时间=1 秒），添加 HTTP 请求（调用库存扣减接口 POST http://localhost:8081/api/stock/deduct，参数 productId=1&deductCount=1）。
3. 服务部署：启动 2 个商品服务实例（端口 8081、8082），注册到 Nacos，模拟集群部署。

7.2 测试步骤与预期结果

步骤 1：库存防超卖测试

• 测试操作：执行 JMeter 测试，模拟 1000 个并发请求，每个请求扣减 1 个库存。
• 预期结果：
  1. 最终可用库存 = 0，锁定库存 = 1000，总库存 = 1000，无超卖；
  2. 所有请求中，1000 个成功，0 个失败（库存不足）。

步骤 2：缓存有效性测试

• 测试操作：多次查询商品 ID=1 的信息，观察缓存命中情况。
• 预期结果：
  1. 第一次查询：缓存未命中，查询数据库并写入缓存；
  2. 后续查询：缓存命中，直接返回缓存数据，响应时间从毫秒级降至微秒级。

步骤 3：分布式锁并发控制测试

• 测试操作：在 2 个服务实例同时运行的情况下，执行 JMeter 高并发测试。
• 预期结果：
  1. 分布式锁有效控制跨服务并发，无重复扣减或超卖；
  2. 数据库乐观锁配合分布式锁，确保库存数据精准。

7.3 性能测试指标

8. 避坑指南：企业级落地的 6 个核心注意点

8.1 避坑 1：分布式锁粒度太粗

问题：使用全局锁（如 lockKey = "stock:deduct"），所有商品的库存扣减都竞争同一把锁，导致并发性能急剧下降。 解决方案：按商品 ID 粒度加锁，细化锁的范围，提升并发性能。

8.2 避坑 2：缓存更新策略错误

问题：采用'先删缓存，再更数据库'的策略，导致高并发场景下出现脏数据。 解决方案：采用'先更数据库，再删缓存'的策略，配合定时任务校验缓存一致性。

8.3 避坑 3：乐观锁重试次数过多

问题：乐观锁无限重试，导致长耗时业务阻塞，影响系统吞吐量。 解决方案：设置最大重试次数（如 3 次），超过次数后返回失败，引导用户重试。

8.4 避坑 4：分布式锁未释放

问题：业务执行过程中抛出异常，未在 finally 块中释放锁，导致死锁。 解决方案：在 finally 块中释放锁，确保锁最终被释放；同时利用 Redisson 的自动续期和超时释放机制，作为双重保障。

8.5 避坑 5：缓存空值未设置过期时间

问题：为解决缓存穿透，缓存空值但未设置过期时间，导致 Redis 中积累大量空值缓存，占用内存。 解决方案：缓存空值时设置短期过期时间（如 1 分钟），避免内存浪费。

8.6 避坑 6：库存字段设计不合理

问题：仅设计总库存字段，未区分可用库存和锁定库存，导致订单未支付时占用库存，影响其他用户下单。 解决方案：设计总库存、可用库存、锁定库存三个字段，实现库存的精细化管控。

9. 总结与展望

9.1 核心总结

本文完整实现了企业级 Spring Cloud 商品服务，聚焦三大核心业务，取得以下成果：

1. 库存管理：采用'总库存 + 可用库存 + 锁定库存'的字段设计，结合乐观锁与重试机制，实现精准库存扣减，杜绝超卖；
2. 缓存设计：针对缓存穿透、击穿、雪崩三大问题，提供布隆过滤器 + 缓存空值、热点商品永不过期 + 互斥锁、过期时间加随机值的完整解决方案，同时保障缓存与数据库的一致性；
3. 分布式锁：基于 Redisson 实现分布式锁，按商品 ID 细化锁粒度，配合乐观锁实现双重并发控制，解决微服务集群下的并发安全问题。

9.2 进阶扩展方向

1. 库存预占与超时释放：实现订单创建时预占库存，超过支付时间自动释放库存，提升库存利用率；
2. 多级缓存设计：引入本地缓存（Caffeine）+ Redis 分布式缓存，进一步提升缓存响应速度，降低 Redis 压力；
3. 分布式事务：集成 Seata 实现分布式事务，确保商品服务与订单服务的库存扣减、订单创建数据一致性；
4. 热点商品隔离：对热点商品进行单独的缓存和库存管理，避免热点商品占用过多系统资源，影响其他商品服务；
5. 监控与告警：集成 Prometheus + Grafana，监控库存变化、缓存命中率、分布式锁竞争情况，设置异常告警阈值，保障系统稳定运行。