登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›商品中心—15.库存分桶扣减的技术文档

商品中心—15.库存分桶扣减的技术文档

厌外 2025-6-27 22:31:04
大纲
1.库存分桶扣减和扩容时涉及的数据表
2.下单时商品库存扣减
3.库存分桶扣减后异步更新DB
4.取消订单时回退商品库存
5.查询商品库存
6.库存扣减分桶轮询以及随机备用分桶
7.基于Tair中分桶数据实现库存扣减
8.分桶库存扣减完毕后扣减明细异步落库
9.分桶扣减完库存后异步触发回源扩容
10.库存分桶回源扩容的Double Check
11.库存分桶扩容量计算算法实现
12.库存分桶扩容完成以及分桶下线触发
13.库存分桶下线以及剩余存量归还中心桶
14.库存下线触发剩余库存总量预警机制
 
1.库存分桶扣减和扩容时涉及的数据表
(1)库存分桶配置表
(2)库存扣减明细表
 
(1)库存分桶配置表
  1. CREATE TABLE `inventory_bucket_config` (
  2.     `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  3.     `bucket_num` int(10)  NOT NULL DEFAULT '0' COMMENT  '分桶数量',
  4.     `max_depth_num` int(10)  NOT NULL DEFAULT '0' COMMENT  '最⼤库存深度，即分桶的最大库存容量',
  5.     `min_depth_num` int(10)  NOT NULL DEFAULT '0' COMMENT  '最⼩库存深度，即分桶的最小库存容量',
  6.     `threshold_value` int(10)  NOT NULL DEFAULT '0' COMMENT  '分桶下线阈值，当某个分桶的库存数小于阈值时就需要将该分桶下线了',
  7.     `back_source_proportion` int(10)  NOT NULL DEFAULT '0' COMMENT  '回源⽐例，从1-100设定⽐例',
  8.     `back_source_step` int(10)  NOT NULL DEFAULT '0' COMMENT  '回源步⻓，桶扩容的时候默认每次分配的库存⼤⼩',
  9.     `template_name` varchar(64) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '模板名称',
  10.     `is_default` tinyint(1)  NOT NULL DEFAULT '0' COMMENT '是否默认模板，只允许⼀个，1为默认模板',
  11.     `version_id` int(10) NOT NULL DEFAULT '0' COMMENT '版本号',
  12.     `del_flag` tinyint(1) NOT NULL DEFAULT '0' COMMENT '删除标记(1-有效，0-删除)',
  13.     `create_user` int(10) NOT NULL DEFAULT '0' COMMENT '创建⼈',
  14.     `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  15.     `update_user` int(10) NOT NULL DEFAULT '0' COMMENT '更新⼈',
  16.     `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  17.     PRIMARY KEY (`ID`)
  18. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='库存分桶配置模板表';
复制代码
(2)库存扣减明细表
  1. CREATE TABLE `inventory_deduction_detail` (
  2.     `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  3.     `order_id` varchar(32) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '订单id',
  4.     `refund_no` varchar(32) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '退款编号',
  5.     `inventory_num` int(10)  NOT NULL DEFAULT '0' COMMENT  '扣减库存数量',
  6.     `sku_id` varchar(64) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '商品skuId',
  7.     `seller_id` varchar(64) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '卖家ID',
  8.     `bucket_no` int(10)  NOT NULL COMMENT  '扣减分桶编号',
  9.     `deduction_type` int(2)  NOT NULL COMMENT  '库存操作类型(10库存扣减，20库存退货)',
  10.     `del_flag` tinyint(1) NOT NULL DEFAULT '0' COMMENT '删除标记(1-有效，0-删除)',
  11.     `create_user` int(10) NOT NULL DEFAULT '0' COMMENT '创建⼈',
  12.     `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  13.     `update_user` int(10) NOT NULL DEFAULT '0' COMMENT '更新⼈',
  14.     `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  15.     PRIMARY KEY (`ID`)
  16. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='库存扣减明细表';
复制代码
(3)流程图
1.png
 
2.下单时商品库存扣减
(1)使用入口
(2)场景一之扣减库存
(3)场景二之扩容库存
(4)场景三之分桶下线
 
(1)使用入口
⽤户在前端下单时，会对商品库存发起扣减请求。
  1. @RestController
  2. @RequestMapping("/product/inventory")
  3. public class InventoryController {
  4.     @Autowired
  5.     private InventoryService inventoryService;
  6.     ...
  8.     //扣减库存
  9.     @RequestMapping("/deduct")
  10.     public JsonResult deductProductStock(@RequestBody InventoryRequest request) {
  11.         //这里模拟指定本次的库存业务单号，实际接口需要外部传入
  12.         request.setOrderId(SnowflakeIdWorker.getCode());
  13.         JsonResult result = inventoryService.deductProductStock(request);
  14.         return result;
  15.     }
  16.     ...
  17. }
  19. @Service
  20. public class InventoryServiceImpl implements InventoryService {
  21.     ...
  22.     //扣减商品库存
  23.     @Override
  24.     public JsonResult deductProductStock(InventoryRequest request) {
  25.         //1.验证入参是否合法
  26.         checkDeductProductStock(request);
  27.         //2.构建扣减库存的上下文对象
  28.         BucketContext bucketContext = buildDeductProductStock(request);
  29.         try {
  30.             //3.获取是否已经有一条扣减明细记录，检查该笔订单号是否已经在缓存中存在
  31.             String repeatDeductInfo = getRepeatDeductInfo(bucketContext);
  32.             if (!StringUtils.isEmpty(repeatDeductInfo)) {
  33.                 return JsonResult.buildSuccess();
  34.             }
  35.             //4.执行库存扣减
  36.             deductInventory(bucketContext);
  37.             //5.写入明细，如果已重复写入，则写入失败，并回退库存
  38.             writeInventoryDetail(bucketContext);
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.             return JsonResult.buildError(e.getMessage());
  42.         } finally {
  43.             //6.检测当前返回的库存数量是否触发扩容的阈值(回源比例)，触发则发送通知进行异步扩容
  44.             checkInventoryBackSource(bucketContext);
  45.         }
  46.         return JsonResult.buildSuccess();
  47.     }
  48.     ...
  49. }
复制代码
(2)场景一之扣减库存
  1. 步骤一：库存扣减请求的⼊参校验
  2. 步骤二：构建扣减库存的上下文对象
  3. 步骤三：检查该笔订单号是否已经在缓存中存在
  4. 步骤四：执⾏库存扣减时会⽤到备⽤的分桶进行尝试
  5. 步骤五：扣减成功后写入⼀条执⾏明细到缓存
  6. 步骤六：⽆论整个扣减流程是否成功，都要执⾏⼀次是否扩容的校验判断
复制代码
步骤一：库存扣减请求的⼊参校验
 
步骤二：构建扣减库存的上下文对象。接下来进⾏校验和扣减都会以这个上下文对象的信息为准。构建该上下文对象时，首先会根据⼀个⾃增的访问次数key来定位本次扣减应该路由到哪个分桶。也就是使用Round Robin轮询算法，根据扣减次数定位具体要扣减哪个分桶。为避免扣减失败，会同时随机⽣成2个备⽤分桶，用于扣减失败时的重试。如果其他分桶都作为备用分桶，那么就是库存合并扣减的功能了。
 
⼀般出现连续多个分桶库存都不⾜且分桶还未被进行下线处理的概率较少，此种场景的分桶应该⼤部分都已下线，且只保留了唯⼀⼀个可⽤分桶。获取分桶元数据时，会先从本地缓存获取，然后再从Tair缓存中获取。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     ...
  4.     //构建接下来用于处理具体扣减库存时所需要的上下文对象
  5.     private BucketContext buildDeductProductStock(InventoryRequest request) {
  6.         //1.填充扣减库存相关请求信息的明细
  7.         InventoryDetail inventoryDetail = inventoryConverter.converterRequest(request);
  8.         //2.填充扣减库存的分桶相关信息
  9.         BucketContext bucketContext = buildDeductBucketList(request);
  10.         bucketContext.setInventoryDetail(inventoryDetail);
  11.         return bucketContext;
  12.     }
  14.     //填充扣减库存的分桶相关信息
  15.     private BucketContext buildDeductBucketList(InventoryRequest request) {
  16.         BucketContext context = new BucketContext();
  17.         //获取本地缓存的分桶元数据
  18.         BucketLocalCache bucketLocalCache = inventoryBucketCache.getBucketLocalCache(request.getSellerId() + request.getSkuId());
  19.         //获取本地缓存的分桶列表
  20.         List<BucketCacheBO> availableList = bucketLocalCache.getAvailableList();
  22.         //获取本次扣减请求对应的扣减次数，用来定位具体使用的分桶库存
  23.         Integer incrementCount = getIncrementCount(request);
  25.         //通过取模运算得到本次访问所需要定位的分桶，使用Round Robin轮询算法
  26.         int index = incrementCount % availableList.size();
  28.         //获取本次准备处理的分桶信息
  29.         BucketCacheBO bucketCacheBO = availableList.get(index);
  30.         context.getAvailableList().add(bucketCacheBO);
  31.         context.getBucketNoList().add(bucketCacheBO.getBucketNo());
  33.         //获取分桶配置信息
  34.         context.setInventoryBucketConfig(bucketLocalCache.getInventoryBucketConfig());
  36.         //为了避免扣减失败(分桶已下线或者库存不足)，可以多备份几个分桶
  37.         //如果其他分桶都作为备用分桶，那么就可以实现库存合并扣减的功能了
  38.         for (int i = 0; i < 2; i++) {
  39.             //任意填充2个作为备份
  40.             Random random = new Random();
  41.             int num = random.nextInt(availableList.size());
  43.             BucketCacheBO bucketCache = availableList.get(num);
  44.             //避免拿到重复的分桶，这里处理一下
  45.             if (context.getBucketNoList().contains(bucketCache.getBucketNo())) {
  46.                 i--;
  47.                 continue;
  48.             }
  49.             context.getAvailableList().add(bucketCache);
  50.             context.getBucketNoList().add(bucketCache.getBucketNo());
  51.         }
  52.         return context;
  53.     }
  55.     //获取对应售卖商品的扣减访问次数
  56.     private Integer getIncrementCount(InventoryRequest request) {
  57.         String incrementKey = TairInventoryConstant.SELLER_SKU_STOCK_COUNT_PREFIX + request.getSellerId() + request.getSkuId();
  58.         Integer incrementCount = tairCache.incr(incrementKey);
  59.         return incrementCount;
  60.     }
  61.     ...
  62. }
  64. @Component
  65. @Data
  66. public class InventoryBucketCache {
  67.     @Autowired
  68.     private Cache cache;
  70.     @Autowired
  71.     private TairCache tairCache;
  72.     ...
  74.     //获取本地缓存的分桶元数据信息
  75.     public BucketLocalCache getBucketLocalCache(String bucketKey) {
  76.         BucketLocalCache bucketLocalCache = (BucketLocalCache) cache.getIfPresent(bucketKey);
  77.         log.info("local cache get key:{}, value:{}", bucketKey, JSON.toJSONString(bucketLocalCache));
  78.         if (Objects.isNull(bucketLocalCache)) {
  79.             synchronized (bucketKey.intern()) {
  80.                 String bucketCache = tairCache.get(TairInventoryConstant.SELLER_BUCKET_PREFIX + bucketKey);
  81.                 if (!StringUtils.isEmpty(bucketCache)) {
  82.                     bucketLocalCache = JsonUtil.json2Object(bucketCache, BucketLocalCache.class);
  83.                     cache.put(bucketKey, bucketLocalCache);
  84.                 }
  85.             }
  86.         }
  87.         return bucketLocalCache;
  88.     }
  89.     ...
  90. }
  92. //分桶扣减库存上下文对象
  93. @Data
  94. public class BucketContext {
  95.     //存储可用的分桶编号
  96.     private List<String> bucketNoList = new ArrayList<>();
  97.     //存储可用的分桶的具体信息
  98.     private List<BucketCacheBO> availableList  = new ArrayList<>();
  99.     //扣减明细信息
  100.     private InventoryDetail inventoryDetail;
  101.     //用来处理扩容所用
  102.     private Map<String, Integer> capacityMap = new HashMap<>();
  103.     //当前分桶的配置信息
  104.     private InventoryBucketConfigDO inventoryBucketConfig;
  105. }
  107. //库存扣减的明细对象
  108. @Data
  109. public class InventoryDetail {
  110.     //商品SKU
  111.     private Long skuId;
  112.     //扣减库存数量
  113.     private Integer inventoryNum;
  114.     //卖家ID
  115.     private String sellerId;
  116.     //订单ID
  117.     private String orderId;
  118.     //扣减使用的分桶
  119.     private String bucketNo;
  120.     //退款编号
  121.     private String refundNo;
  122. }
复制代码
步骤三：检查该笔订单号是否已经在缓存中存在。如果已经存在则认为这笔订单已被扣减过库存了，可以直接返回。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  5.     ...
  7.     //验证当前得请求扣减是否已经存在了
  8.     private String getRepeatDeductInfo(BucketContext bucketContext) {
  9.         //获取当前扣减库存对应的订单明细缓存
  10.         String key = TairInventoryConstant.SELLER_SKU_TRADE_DETAIL_PREFIX + bucketContext.getInventoryDetail().getSellerId();
  11.         return tairCache.exhget(key, String.valueOf(bucketContext.getInventoryDetail().getOrderId()));
  12.     }
  13.     ...
  14. }
  16. @Component
  17. public class TairCache {
  18.     private JedisPool jedisPool;
  20.     public TairCache(JedisPool jedisPool) {
  21.         this.jedisPool = jedisPool;
  22.     }
  24.     public Jedis getJedis() {
  25.         return jedisPool.getResource();
  26.     }
  28.     private TairHash createTairHash(Jedis jedis) {
  29.         return new TairHash(jedis);
  30.     }
  32.     //获取hash对象
  33.     public String exhget(String key, String field) {
  34.         try (Jedis jedis = getJedis()) {
  35.             String exhget = createTairHash(jedis).exhget(key, field);
  36.             log.info("exhget key:{}, field:{}, value:{}", key, field, exhget);
  37.             return exhget;
  38.         }
  39.     }
  40. }
复制代码
步骤四：执⾏库存扣减时会⽤到备⽤的分桶进行尝试。当第⼀次分桶扣减库存失败，默认会重试其它⼏个分桶。如果都失败则直接提示库存不⾜抛出异常。如果备用的分桶全部是可用的分桶，那么第一个分桶不够扣，就会继续扣第二个分桶，从而实现库存合并扣减。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  5.     ...
  7.     //扣减库存
  8.     //@param bucketContext 库存扣减上下文对象
  9.     private void deductInventory(BucketContext bucketContext) {
  10.         //获取可以使用的分桶编号，即对应缓存中的key
  11.         List<String> bucketNoList = bucketContext.getBucketNoList();
  12.         //获取扣减明细信息
  13.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  14.         //获取扣减库存数量
  15.         Integer inventoryNum = inventoryDetail.getInventoryNum();
  16.         //获取用于处理扩容的Map
  17.         Map<String, Integer> capacityMap = bucketContext.getCapacityMap();
  18.         Boolean isDeduct = false;
  19.         //对分桶进行库存扣减(每次)
  20.         //如果bucketNoList是全部可用分桶，那么第一个分桶不够扣减，就会继续扣减第二个分桶，从而实现库存合并扣减
  21.         for (String bucketNo : bucketNoList) {
  22.             //自减，默认扣减后不能小于0，否则返回-1
  23.             Integer residueNum = tairCache.decr(bucketNo, inventoryNum);
  24.             //capacityMap可用于判断分桶是否是扩容的分桶，以及标记当前分桶剩余的库存数
  25.             capacityMap.put(bucketNo, residueNum);
  26.             //库存扣减成功
  27.             if (residueNum >= 0) {
  28.                 //标记一下具体扣减的分桶属于哪个
  29.                 inventoryDetail.setBucketNo(bucketNo);
  30.                 isDeduct = true;
  31.                 break;
  32.             }
  33.         }
  34.         //分桶扣减都没有成功，此时抛出异常提示库存不足
  35.         if (!isDeduct) {
  36.             throw new BaseBizException(InventoryExceptionCode.INVENTORY_INSUFFICIENT_ERROR);
  37.         }
  38.     }
  39.     ...
  40. }
复制代码
步骤五：扣减成功后写入⼀条执⾏明细到缓存。注意并发场景下可能获取时没有明细，但写⼊时⼜有明细了。⼀旦发⽣这种场景，说明并发了，需要进⾏库存的回退。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  6.     @Resource
  7.     private InventoryDetailProducer inventoryDetailProducer;
  8.     ...
  10.     //将库存明细写入缓存(写入失败则代表已经被写入了，此时需要回退库存)
  11.     private void writeInventoryDetail(BucketContext bucketContext) {
  12.         //获取扣减明细信息
  13.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  14.         String key = TairInventoryConstant.SELLER_SKU_TRADE_DETAIL_PREFIX + bucketContext.getInventoryDetail().getSellerId();
  15.         //尝试写入明细记录，如果没有写入成功则说明库存需要回退
  16.         Integer count = tairCache.exhset(key, String.valueOf(inventoryDetail.getOrderId()), JSONObject.toJSONString(inventoryDetail));
  17.         if (count < 0) {
  18.             //说明明细已经存在了，写入失败，此时需要将库存回退到对应的分桶上
  19.             tairCache.incr(inventoryDetail.getBucketNo(), inventoryDetail.getInventoryNum());
  20.         } else {
  21.             //发送消息，异步写入库存扣减的明细到DB
  22.             inventoryDetailProducer.sendInventoryDetail(bucketContext.getInventoryDetail());
  23.         }
  24.     }
  25.     ...
  26. }
  28. @Component
  29. public class TairCache {
  30.     private JedisPool jedisPool;
  32.     public TairCache(JedisPool jedisPool) {
  33.         this.jedisPool = jedisPool;
  34.     }
  36.     public Jedis getJedis() {
  37.         return jedisPool.getResource();
  38.     }
  40.     private TairHash createTairHash(Jedis jedis) {
  41.         return new TairHash(jedis);
  42.     }
  44.     //存储hash对象
  45.     public Integer exhset(String key,String field, String value){
  46.         try (Jedis jedis = getJedis()) {
  47.             return createTairHash(jedis).exhset(key, field, value, ExhsetParams.ExhsetParams().nx()).intValue();
  48.         }
  49.     }
  50. }
复制代码
步骤六：⽆论整个扣减流程是否成功，都要执⾏⼀次是否扩容的校验判断。执⾏依据是分桶扣减完库存后返回的扣减后剩余库存值以及对应的分桶。例如第⼀个分桶失败，第⼆个分桶成功，必然会触发第⼀个分桶的扩容。然后校验第⼆个分桶的库存返回值是否触发回源⽐例后决定是否触发扩容。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     ...
  4.     //扣减商品库存
  5.     @Override
  6.     public JsonResult deductProductStock(InventoryRequest request) {
  7.         //1.验证入参是否合法
  8.         checkDeductProductStock(request);
  9.         //2.构建扣减库存的上下文对象
  10.         BucketContext bucketContext = buildDeductProductStock(request);
  11.         try {
  12.             //3.获取是否已经有一条扣减明细记录，检查该笔订单号是否已经在缓存中存在
  13.             String repeatDeductInfo = getRepeatDeductInfo(bucketContext);
  14.             if (!StringUtils.isEmpty(repeatDeductInfo)) {
  15.                 return JsonResult.buildSuccess();
  16.             }
  17.             //4.执行库存扣减
  18.             deductInventory(bucketContext);
  19.             //5.写入明细，如果已重复写入，则写入失败，并回退库存
  20.             writeInventoryDetail(bucketContext);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.             return JsonResult.buildError(e.getMessage());
  24.         } finally {
  25.             //6.检测当前返回的库存数量是否触发扩容的阈值(回源比例)，触发则异步通知扩容
  26.             checkInventoryBackSource(bucketContext);
  27.         }
  28.         return JsonResult.buildSuccess();
  29.     }
  30.     ...
  32.     //检测扣减成功后的库存是否触发回源
  33.     //例如商品分桶库存1000，回源比例40%，那么实际剩余库存小于400就会触发回源库存的操作
  34.     private void checkInventoryBackSource(BucketContext bucketContext) {
  35.         //获取扣减明细信息
  36.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  37.         //存储对应的需要校验扩容的分桶
  38.         Map<String, Integer> bucketMap = bucketContext.getCapacityMap();
  39.         //获取库存分桶配置
  40.         InventoryBucketConfigDO inventoryBucketConfig = bucketContext.getInventoryBucketConfig();
  42.         //判断分桶当初分配的最大库存容量，计算是否触发回源比例
  43.         List<BucketCacheBO> availableList = bucketContext.getAvailableList();
  44.         for (BucketCacheBO bucketCacheBO : availableList) {
  45.             //具体使用的是哪个分桶扣减库存
  46.             if (bucketMap.containsKey(bucketCacheBO.getBucketNo())) {
  47.                 Integer residueNum = bucketMap.get(bucketCacheBO.getBucketNo());
  48.                 //当前分桶的分配总库存
  49.                 Integer bucketNum = bucketCacheBO.getBucketNum();
  50.                 //触发回源比例的百分比
  51.                 Integer backSourceProportion = inventoryBucketConfig.getBackSourceProportion();
  52.                 //这里如果要更准确，需要用小数得到回源数，剩余数量小于回源数，那么就要回源
  53.                 //这里省略了小数，所以可能会有一个数的误差，影响不大
  54.                 int backSourceNum = bucketNum * backSourceProportion / 100;
  56.                 //回源比例的库存 大于剩余的库存，触发异步扩容，或者没有返回剩余库存也说明扣减失败
  57.                 if (backSourceNum > residueNum) {
  58.                     //标记出回源的具体分桶
  59.                     inventoryDetail.setBucketNo(bucketCacheBO.getBucketNo());
  60.                     //发送通知到消息队列进行异步库存扩容
  61.                     sendAsynchronous(inventoryDetail);
  62.                 }
  63.             }
  64.         }
  65.     }
  66.     ...
  67. }
复制代码
(3)场景二之扩容库存
  1. 步骤一：库存分桶缓存的扣减过程会触发库存扩容
  2. 步骤二：消费者消费分桶库存扩容的消息
  3. 步骤三：检测是否需要扩容，如果⽆需扩容则直接结束
  4. 步骤四：获取分布式锁来进行扩容处理或分桶下线处理
  5. 步骤五：进行具体的库存分桶缓存的扩容处理
复制代码
步骤一：库存分桶缓存的扣减过程会触发库存扩容。执⾏库存分桶缓存的扣减时，如果发现分桶的库存剩余值小于回源配置数，此时就需要发送⼀个异步消息，通知该库存分桶进⾏扩容。
 
步骤二：消费者消费分桶库存扩容的消息。此时会调用分桶扩容接口InventoryBucketService的bucketCapacity()来进行扩容。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     ...
  4.     //发送通知到消息队列进行异步库存扩容
  5.     //@param inventoryDetail 库存扣减明细对象
  6.     private void sendAsynchronous(InventoryDetail inventoryDetail) {
  7.         //1.构建发送的消息对象
  8.         BucketCapacity bucketCapacity = inventoryConverter.converter(inventoryDetail);
  9.         //2.发送消息，异步处理扩容
  10.         bucketCapacityProducer.sendBucketCapacity(bucketCapacity);
  11.     }
  12.     ...
  13. }
  15. //分桶扩容对象
  16. @Data
  17. public class BucketCapacity {
  18.     //分桶编号
  19.     private String bucketNo;
  20.     //商品skuID
  21.     private String skuId;
  22.     //卖家ID
  23.     private String sellerId;
  24. }
  26. //分桶扩容的消息队列
  27. @Component
  28. public class BucketCapacityProducer {
  29.     @Autowired
  30.     private DefaultProducer defaultProducer;
  32.     //分桶扩容的消息
  33.     public void sendBucketCapacity(BucketCapacity bucketCapacity) {
  34.         //发送分桶扩容消息
  35.         defaultProducer.sendMessage(RocketMqConstant.BUCKET_CAPACITY_TOPIC, JSONObject.toJSONString(bucketCapacity), "分桶扩容");
  36.     }
  37. }
  39. //消费分桶库存扩容的消息
  40. @Component
  41. public class BucketCapacityListener implements MessageListenerConcurrently {
  42.     @Autowired
  43.     private InventoryBucketService inventoryBucketService;
  45.     @Override
  46.     public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
  47.         try {
  48.             for (MessageExt messageExt : list) {
  49.                 String msg = new String(messageExt.getBody());
  50.                 log.info("执行分桶库存扩容，消息内容：{}", msg);
  51.                 BucketCapacity bucketCapacity = JsonUtil.json2Object(msg, BucketCapacity.class);
  52.                 //调用分桶扩容接口
  53.                 inventoryBucketService.bucketCapacity(bucketCapacity);
  54.             }
  55.         } catch (Exception e) {
  56.             log.error("consume error, 分桶库存扩容失败", e);
  57.             //本次消费失败，下次重新消费
  58.             return ConsumeConcurrentlyStatus.RECONSUME_LATER;
  59.         }
  60.         return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  61.     }
  62. }
  64. @Service
  65. public class InventoryBucketServiceImpl implements InventoryBucketService {
  66.     ...
  67.     //分桶扩容接口
  68.     @Override
  69.     public void bucketCapacity(BucketCapacity bucketCapacity) {
  70.         //先锁住中心桶库存，避免此时库存发生变化
  71.         String key = TairInventoryConstant.SELLER_INVENTORY_LOCK_PREFIX + bucketCapacity.getSellerId() + bucketCapacity.getSkuId();
  72.         String value = SnowflakeIdWorker.getCode();
  73.         //1.校验是否已经无需扩容了，如果是则快速结束
  74.         BucketCapacityContext bucketCapacityContext = checkBucketCapacity(bucketCapacity);
  75.         if (!bucketCapacityContext.getIsCapacity()) {
  76.             return;
  77.         }
  78.         //获取分布式锁来进行扩容处理
  79.         boolean lock = tairLock.tryLock(key, value);
  80.         if (lock) {
  81.             try {
  82.                 //再次校验是否需要扩容，此处不允许并发
  83.                 bucketCapacityContext = checkBucketCapacity(bucketCapacity);
  84.                 if (bucketCapacityContext.getIsCapacity()) {
  85.                     //2.获取中心桶缓存的剩余库存
  86.                     Integer residueNum = getCenterStock(bucketCapacity);
  87.                     //3.可以扩容，计算出可回源的库存进行处理
  88.                     if (residueNum > 0) {
  89.                         backSourceInventory(residueNum, bucketCapacityContext);
  90.                     } else {
  91.                         //4.中心桶无库存，检查是否触发下线
  92.                         checkBucketOffline(bucketCapacity);
  93.                     }
  94.                 }
  95.             } catch (Exception e) {
  96.                 e.printStackTrace();
  97.             } finally {
  98.                 tairLock.unlock(key, value);
  99.             }
  100.         } else {
  101.             throw new BaseBizException("请求繁忙，稍后重试！");
  102.         }
  103.     }
  104.     ...
  105. }
复制代码
步骤三：检测是否需要扩容，如果⽆需扩容则结束
  1. @Service
  2. public class InventoryBucketServiceImpl implements InventoryBucketService {
  3.     ...
  4.     //校验本次请求是否还需要执行扩容处理
  5.     private BucketCapacityContext checkBucketCapacity(BucketCapacity bucketCapacity) {
  6.         String key = bucketCapacity.getSellerId() + bucketCapacity.getSkuId();
  7.         //1.获取远程的分桶缓存信息
  8.         Integer residueNum = getBucketInventoryNum(bucketCapacity.getBucketNo());
  9.         //2.获取缓存元数据信息
  10.         BucketLocalCache bucketLocalCache = inventoryBucketCache.getBucketLocalCache(key);
  11.         //3.校验是否还需要执行扩容
  12.         List<BucketCacheBO> availableList = bucketLocalCache.getAvailableList();
  13.         InventoryBucketConfigDO inventoryBucketConfig = bucketLocalCache.getInventoryBucketConfig();
  14.         for (BucketCacheBO bucketCacheBO:availableList) {
  15.             //具体使用的是哪个分桶进行扣减库存
  16.             if (bucketCacheBO.getBucketNo().equals(bucketCapacity.getBucketNo())) {
  17.                 //当前分桶的分配总库存
  18.                 Integer bucketNum = bucketCacheBO.getBucketNum();
  19.                 //触发回源比例的百分比
  20.                 Integer backSourceProportion = inventoryBucketConfig.getBackSourceProportion();
  21.                 int backSourceNum = bucketNum * backSourceProportion / 100;
  22.                 //回源比例的库存大于剩余的库存，触发异步扩容
  23.                 return new BucketCapacityContext(residueNum, backSourceNum > residueNum, bucketCapacity);
  24.             }
  25.         }
  26.         //如果不在可用列表里面，则意味已下线，快速结束掉
  27.         return new BucketCapacityContext(residueNum, false, bucketCapacity);
  28.     }
  30.     //获取得到当前分桶对应的实际剩余库存
  31.     private Integer getBucketInventoryNum( String bucketNo) {
  32.         String bucketNum = tairCache.get(bucketNo);
  33.         if (StringUtils.isEmpty(bucketNum)){
  34.             return 0;
  35.         }
  36.         return Integer.valueOf(bucketNum);
  37.     }
  38.     ...
  39. }
复制代码
步骤四：获取分布式锁来进行扩容处理或分桶下线处理。这⾥会查看中⼼桶缓存的剩余库存，判断是否还有剩余库存可以扩容。如果有则进⾏扩容，如果没有则判断分桶是否触发下线阈值。并且处理请求前，需要再次判断是否⽆需扩容。避免有竞争锁的请求跳过前面的校验进⼊锁，需要过滤掉这种⽆效请求。
  1. @Service
  2. public class InventoryBucketServiceImpl implements InventoryBucketService {
  3.     ...
  4.     //分桶扩容接口
  5.     @Override
  6.     public void bucketCapacity(BucketCapacity bucketCapacity) {
  7.         //先锁住中心桶库存，避免此时库存发生变化
  8.         String key = TairInventoryConstant.SELLER_INVENTORY_LOCK_PREFIX + bucketCapacity.getSellerId() + bucketCapacity.getSkuId();
  9.         String value = SnowflakeIdWorker.getCode();
  10.         //1.校验是否已经无需扩容了，如果是则快速结束
  11.         BucketCapacityContext bucketCapacityContext = checkBucketCapacity(bucketCapacity);
  12.         if (!bucketCapacityContext.getIsCapacity()) {
  13.             return;
  14.         }
  15.         //获取分布式锁来进行扩容处理
  16.         boolean lock = tairLock.tryLock(key, value);
  17.         if (lock) {
  18.             try {
  19.                 //再次校验是否需要扩容，此处不允许并发
  20.                 bucketCapacityContext = checkBucketCapacity(bucketCapacity);
  21.                 if (bucketCapacityContext.getIsCapacity()) {
  22.                     //2.获取中心桶缓存的剩余库存
  23.                     Integer residueNum = getCenterStock(bucketCapacity);
  24.                     //3.可以扩容，计算出可回源的库存进行处理
  25.                     if (residueNum > 0) {
  26.                         backSourceInventory(residueNum, bucketCapacityContext);
  27.                     } else {
  28.                         //4.中心桶无库存，检查是否触发下线
  29.                         checkBucketOffline(bucketCapacity);
  30.                     }
  31.                 }
  32.             } catch (Exception e) {
  33.                 e.printStackTrace();
  34.             } finally {
  35.                 tairLock.unlock(key, value);
  36.             }
  37.         } else {
  38.             throw new BaseBizException("请求繁忙，稍后重试！");
  39.         }
  40.     }
  41.     ...
  42. }
复制代码
步骤五：进行具体的库存分桶缓存的扩容处理。分桶需要扩容多少库存，需要尽量保证每个分桶的库存尽可能均匀。
  1. @Service
  2. public class InventoryBucketServiceImpl implements InventoryBucketService {
  3.     ...
  4.     //回源库存到分桶上
  5.     //@param residueNum            中心桶库存
  6.     //@param bucketCapacityContext 扩容上下文对象
  7.     private void backSourceInventory(Integer residueNum, BucketCapacityContext bucketCapacityContext) {
  8.         //首先需要当前分桶的库存，其次还需要获取目前分桶的可发库存深度(第一次初始化的时候分配的库存)
  9.         //根据当初分配的库存深度以及最大库存深度以及中心桶库存，得出均匀到目前支持可用的分桶均匀分配库存大概数量
  10.         //同时根据本次同步的库存数量刷新分桶的实际库存深度
  11.         BucketCapacity bucketCapacity = bucketCapacityContext.getBucketCapacity();
  12.         //先获取本地的分桶元数据信息，获取当前分桶的总发放上限
  13.         String key = bucketCapacity.getSellerId() + bucketCapacity.getSkuId();
  14.         BucketLocalCache bucketLocalCache = inventoryBucketCache.getBucketLocalCache(key);
  16.         InventoryBucketConfigDO inventoryBucketConfig = bucketLocalCache.getInventoryBucketConfig();
  17.         List<BucketCacheBO> availableList = bucketLocalCache.getAvailableList();
  18.         Integer inventoryNum = 0;
  19.         //获取实际配置的最大可用库存深度
  20.         Integer maxBucketNum = availableList.stream().mapToInt(BucketCacheBO::getBucketNum).sum();
  21.         BucketCacheBO bucketCache = null;
  22.         for (BucketCacheBO bucketCacheBO : availableList) {
  23.             if (bucketCacheBO.getBucketNo().equals(bucketCapacity.getBucketNo())) {
  24.                 bucketCache = bucketCacheBO;
  25.                 break;
  26.             }
  27.         }
  28.         //这里没有匹配到分桶，则该分桶已被下线，不处理后续流程
  29.         if (Objects.isNull(bucketCache)) {
  30.             return;
  31.         }
  32.         //中心桶库存超过最大深度库存(全部分桶总计)，直接以配置的回源步长增长库存
  33.         if (residueNum > maxBucketNum) {
  34.             inventoryNum = inventoryBucketConfig.getBackSourceStep();
  35.         } else {
  36.             inventoryNum = calcEvenInventoryNum(maxBucketNum, inventoryBucketConfig, residueNum, bucketCache);
  37.         }
  38.         //填充变更元数据关于库存的深度数据
  39.         Integer maxDepthNum = getMaxDepthNum(inventoryNum, inventoryBucketConfig, bucketCache, bucketCapacityContext);
  40.         //更新分桶元数据相关信息，注意需要判断当前分桶的库存深度是否真实发生变化，如无变化则不需要更新
  41.         refreshBucketCache(maxDepthNum, bucketLocalCache, bucketCapacity.getBucketNo(), inventoryNum);
  42.         log.info("本次分桶:{}，回源库存：{}", bucketCapacity.getBucketNo(), inventoryNum);
  43.         //回源分桶的库存
  44.         Integer incr = tairCache.incr(bucketCapacity.getBucketNo(), inventoryNum);
  45.         //扣减中心桶库存
  46.         Integer decr = tairCache.decr(TairInventoryConstant.SELLER_INVENTORY_PREFIX + key, inventoryNum);
  47.         log.info("本次分桶:{}，回源库存：{}, 回源后分桶库存：{}， 中心桶剩余库存：{}", bucketCapacity.getBucketNo(), inventoryNum, incr, decr);
  48.     }
  49.     ...
  50. }
复制代码
(4)场景三之分桶下线
说明一：当中⼼桶库存缓存⽆剩余库存，分桶库存也处于下线的阈值时。为了避免碎⽚化的问题出现，需要将⼀些⼩于阈值的库存进⾏分桶回收。分桶回收也就是，将库存回源到中⼼桶，提供给其它分桶扩容。如此反复，当库存越来越少，最终只留下⼀个分桶扣减库存。
 
说明二：分桶下线采取异步⽅式执⾏，因为分桶下线请求的路由需要时间，所以这⾥对于分桶下线需要先把下线分桶从可⽤列表移除。再通过⼀个延迟消息将对应分桶⾥的库存回源到中⼼桶，避免库存超发。
  1. @Service
  2. public class InventoryBucketServiceImpl implements InventoryBucketService {
  3.     ...
  4.     //校验当前分桶是否触发下线的阈值
  5.     private void checkBucketOffline(BucketCapacity bucketCapacity) {
  6.         //1.获取当前分桶的配置信息
  7.         String key = bucketCapacity.getSellerId() + bucketCapacity.getSkuId();
  8.         BucketLocalCache bucketLocalCache = inventoryBucketCache.getBucketLocalCache(key);
  9.         //2.检测分桶的库存是否触发下线阈值，先获取当前分桶的具体库存以及下线配置阈值
  10.         Integer thresholdValue = bucketLocalCache.getInventoryBucketConfig().getThresholdValue();
  11.         Integer inventoryNum = getBucketInventoryNum(bucketCapacity.getBucketNo());
  12.         //3.如果触发下线，发送消息调用分桶下线
  13.         if (thresholdValue > inventoryNum) {
  14.             log.info("触发下线{}，阈值{}，当前库存值{}", thresholdValue > inventoryNum, thresholdValue, inventoryNum);
  15.             sendAsynchronous(bucketCapacity);
  16.         }
  17.     }
  19.     //对分桶进行异步下线
  20.     private void sendAsynchronous(BucketCapacity bucketCapacity) {
  21.         //1.构建分桶下线接口模型
  22.         InventorOfflineRequest offlineRequest = buildOfflineBucketInfo(bucketCapacity);
  23.         //2.发送消息，通知处理分桶下线
  24.         bucketOfflineProducer.sendBucketOffline(offlineRequest);
  25.     }
  26.     ...
  27. }
复制代码
 
3.库存分桶扣减后异步更新DB
(1)使用入口
(2)具体实现
 
(1)使用入口
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  6.     //扣减商品库存
  7.     @Override
  8.     public JsonResult deductProductStock(InventoryRequest request) {
  9.         //1.验证入参是否合法
  10.         checkDeductProductStock(request);
  11.         //2.构建扣减库存的上下文对象
  12.         BucketContext bucketContext = buildDeductProductStock(request);
  13.         try {
  14.             //3.获取是否已经有一条扣减明细记录，检查该笔订单号是否已经在缓存中存在
  15.             String repeatDeductInfo = getRepeatDeductInfo(bucketContext);
  16.             if (!StringUtils.isEmpty(repeatDeductInfo)) {
  17.                 return JsonResult.buildSuccess();
  18.             }
  19.             //4.执行库存扣减
  20.             deductInventory(bucketContext);
  21.             //5.写入明细，如果已重复写入，则写入失败，并回退库存
  22.             writeInventoryDetail(bucketContext);
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.             return JsonResult.buildError(e.getMessage());
  26.         } finally {
  27.             //6.检测当前返回的库存数量是否触发扩容的阈值(回源比例)，触发则异步通知扩容
  28.             checkInventoryBackSource(bucketContext);
  29.         }
  30.         return JsonResult.buildSuccess();
  31.     }
  33.     //将库存明细写入缓存(写入失败则代表已经被写入了，此时需要回退库存)
  34.     private void writeInventoryDetail(BucketContext bucketContext) {
  35.         //获取扣减明细信息
  36.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  37.         String key = TairInventoryConstant.SELLER_SKU_TRADE_DETAIL_PREFIX + bucketContext.getInventoryDetail().getSellerId();
  38.         //尝试写入明细记录，如果没有写入成功则说明库存需要回退
  39.         Integer count = tairCache.exhset(key, String.valueOf(inventoryDetail.getOrderId()), JSONObject.toJSONString(inventoryDetail));
  40.         if (count < 0) {
  41.             //说明明细已经存在了，写入失败，此时需要将库存回退到对应的分桶上
  42.             tairCache.incr(inventoryDetail.getBucketNo(), inventoryDetail.getInventoryNum());
  43.         } else {
  44.             //发送消息，异步写入库存扣减的明细到DB
  45.             inventoryDetailProducer.sendInventoryDetail(bucketContext.getInventoryDetail());
  46.         }
  47.     }
  48.     ...
  49. }
  51. //库存扣减明细
  52. @Component
  53. public class InventoryDetailProducer {
  54.     @Autowired
  55.     private DefaultProducer defaultProducer;
  57.     //库存扣减明细 MQ生产
  58.     public void sendInventoryDetail(InventoryDetail inventoryDetail) {
  59.         //发送库存扣减 明细保存消息
  60.         defaultProducer.sendAsyncMessage(RocketMqConstant.INVENTORY_DETAIL_TOPIC, JSONObject.toJSONString(inventoryDetail), "库存扣减明细");
  61.     }
  62. }
复制代码
(2)具体实现
说明一：当有任意⼀个库存发⽣扣减或者撤销时，会将此次发⽣变化的库存具体明细进⾏消息发送。
 
说明二：扣减需要验证是否已有该订单号的库存明细记录，同样的记录只允许⽣成⼀次，重复则抛出唯⼀索引异常。捕获异常返回成功消息，不写⼊数据库。
 
说明三：写入数据库时，通过批量插入库存明细代替单条数据插入。
  1. //处理库存扣减明细的记录消息
  2. @Component
  3. public class InventoryDetailListener implements MessageListenerConcurrently {
  4.     @Resource
  5.     private InventoryRepository inventoryRepository;
  7.     @Override
  8.     public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
  9.         try {
  10.             log.info("执行库存扣减明细保存，消息数量：{}", list.size());
  11.             List<InventoryDetail> inventoryDetailList = new ArrayList<>(list.size());
  12.             for (MessageExt messageExt : list) {
  13.                 String msg = new String(messageExt.getBody());
  14.                 InventoryDetail inventoryDetail = JsonUtil.json2Object(msg, InventoryDetail.class);
  15.                 inventoryDetailList.add(inventoryDetail);
  16.             }
  17.             inventoryRepository.saveInventoryDetailList(inventoryDetailList, InventoryDeductionTypeEnum.INVENTORY_DETAIL_DEDUCTIONS_TYPE.getCode());
  18.         } catch (DuplicateKeyException ex) {
  19.             log.error("consume repeat, 库存扣减明细重复记录,不再重复执行", ex);
  20.             return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  21.         } catch (Exception e) {
  22.             log.error("consume error, 库存扣减明细保存失败", e);
  23.             //本次消费失败，下次重新消费
  24.             return ConsumeConcurrentlyStatus.RECONSUME_LATER;
  25.         }
  26.         return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  27.     }
  28. }
  30. @Repository
  31. public class InventoryRepository {
  32.     ...
  33.     //批量保存库存扣减的明细
  34.     public void saveInventoryDetailList(List<InventoryDetail> inventoryDetailList, Integer deductionType) throws DuplicateKeyException {
  35.         List<InventoryDeductionDetailDO> inventoryDeductionDetailDOList = inventoryConverter.converterDOList(inventoryDetailList);
  36.         //对象转换赋值
  37.         for (InventoryDeductionDetailDO inventoryDeductionDetailDO : inventoryDeductionDetailDOList) {
  38.             inventoryDeductionDetailDO.setDeductionType(deductionType);
  39.             inventoryDeductionDetailDO.initCommon();
  40.         }
  41.         int count = inventoryDetailMapper.insertBatch(inventoryDeductionDetailDOList);
  42.         if (count <= 0) {
  43.             throw new BaseBizException(InventoryExceptionCode.INVENTORY_SQL);
  44.         }
  45.     }
  46.     ...
  47. }
复制代码
 
8.分桶库存扣减完毕后扣减明细异步落库
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  6.     @Resource
  7.     private InventoryDetailProducer inventoryDetailProducer;
  8.     ...
  10.     //将库存明细写入缓存(写入失败则代表已经被写入了，此时需要回退库存)
  11.     private void writeInventoryDetail(BucketContext bucketContext) {
  12.         //获取扣减明细信息
  13.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  14.         String key = TairInventoryConstant.SELLER_SKU_TRADE_DETAIL_PREFIX + bucketContext.getInventoryDetail().getSellerId();
  15.         //尝试写入明细记录，如果没有写入成功则说明库存需要回退
  16.         Integer count = tairCache.exhset(key, String.valueOf(inventoryDetail.getOrderId()), JSONObject.toJSONString(inventoryDetail));
  17.         if (count < 0) {
  18.             //说明明细已经存在了，写入失败，此时需要将库存回退到对应的分桶上
  19.             tairCache.incr(inventoryDetail.getBucketNo(), inventoryDetail.getInventoryNum());
  20.         } else {
  21.             //发送消息，异步写入库存扣减的明细到DB
  22.             inventoryDetailProducer.sendInventoryDetail(bucketContext.getInventoryDetail());
  23.         }
  24.     }
  25.     ...
  26. }
  28. @Component
  29. public class TairCache {
  30.     private JedisPool jedisPool;
  32.     public TairCache(JedisPool jedisPool) {
  33.         this.jedisPool = jedisPool;
  34.     }
  36.     public Jedis getJedis() {
  37.         return jedisPool.getResource();
  38.     }
  40.     private TairHash createTairHash(Jedis jedis) {
  41.         return new TairHash(jedis);
  42.     }
  44.     //存储hash对象
  45.     public Integer exhset(String key,String field, String value){
  46.         try (Jedis jedis = getJedis()) {
  47.             return createTairHash(jedis).exhset(key, field, value, ExhsetParams.ExhsetParams().nx()).intValue();
  48.         }
  49.     }
  50. }//处理库存扣减明细的记录消息@Componentpublic class InventoryDetailListener implements MessageListenerConcurrently {    @Resource    private InventoryRepository inventoryRepository;    @Override    public ConsumeConcurrentlyStatus consumeMessage(List list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {        try {            log.info("执行库存扣减明细保存，消息数量：{}", list.size());            List inventoryDetailList = new ArrayList(list.size());            for (MessageExt messageExt : list) {                String msg = new String(messageExt.getBody());                InventoryDetail inventoryDetail = JsonUtil.json2Object(msg, InventoryDetail.class);                inventoryDetailList.add(inventoryDetail);            }            inventoryRepository.saveInventoryDetailList(inventoryDetailList, InventoryDeductionTypeEnum.INVENTORY_DETAIL_DEDUCTIONS_TYPE.getCode());        } catch (DuplicateKeyException ex) {            log.error("consume repeat, 库存扣减明细重复记录,不再重复执行", ex);            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;        } catch (Exception e) {            log.error("consume error, 库存扣减明细保存失败", e);            //本次消费失败，下次重新消费            return ConsumeConcurrentlyStatus.RECONSUME_LATER;        }        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;    }}
复制代码
 
9.分桶扣减完库存后异步触发回源扩容
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private InventoryRepository inventoryRepository;
  5.     ...
  7.     //保存退还库存记录
  8.     private InventoryDetail saveRefundInventoryDetail(InventoryRequest request) {
  9.         InventoryDetail inventoryDetail = inventoryRepository.getInventoryDetail(request.getOrderId());
  10.         if (Objects.isNull(inventoryDetail)) {
  11.             throw new BaseBizException(InventoryExceptionCode.INVENTORY_DETAIL_NULL_ERROR, InventoryExceptionCode.INVENTORY_DETAIL_NULL_ERROR.getErrorCode());
  12.         }
  13.         //校验对应订单的退款库存申请记录
  14.         List<InventoryDetail> inventoryDetails = inventoryRepository.queryRefundInventoryDetailList(request.getOrderId());
  15.         Integer refundNum = 0;
  16.         //校验已退库存 + 本次申请退货库存 是否超过下单库存
  17.         if (!CollectionUtils.isEmpty(inventoryDetails)) {
  18.             for (InventoryDetail inventoryDetail1 : inventoryDetails) {
  19.                 refundNum = refundNum + inventoryDetail1.getInventoryNum();
  20.             }
  21.         }
  22.         //如果扣减的库存大于已退库存和本次退的库存，则允许退货
  23.         if (inventoryDetail.getInventoryNum() > (refundNum + request.getInventoryNum())) {
  24.             InventoryDetail inventoryRefundDetail = inventoryConverter.converterRequest(request);
  25.             inventoryRepository.saveInventoryDetail(inventoryRefundDetail, InventoryDeductionTypeEnum.INVENTORY_DETAIL_REFUND_TYPE.getCode());
  26.             return inventoryRefundDetail;
  27.         }
  28.         return null;
  29.     }
  30.     ...
  31. }
  33. @Repository
  34. public class InventoryRepository {
  35.     ...
  36.     //根据订单号查询 库存扣减明细
  37.     public InventoryDetail getInventoryDetail(String orderId) {
  38.         LambdaQueryWrapper<InventoryDeductionDetailDO> queryWrapper = Wrappers.lambdaQuery();
  39.         queryWrapper.eq(InventoryDeductionDetailDO::getOrderId, orderId);
  40.         queryWrapper.eq(InventoryDeductionDetailDO::getDeductionType, InventoryDeductionTypeEnum.INVENTORY_DETAIL_DEDUCTIONS_TYPE.getCode());
  41.         InventoryDeductionDetailDO inventoryDeductionDetailDO = inventoryDetailMapper.selectOne(queryWrapper);
  42.         return inventoryConverter.converter(inventoryDeductionDetailDO);
  43.     }
  45.     //获取扣减库存对应的已退明细
  46.     public List<InventoryDetail> queryRefundInventoryDetailList(String orderId) {
  47.         LambdaQueryWrapper<InventoryDeductionDetailDO> queryWrapper = Wrappers.lambdaQuery();
  48.         queryWrapper.eq(InventoryDeductionDetailDO::getOrderId, orderId);
  49.         queryWrapper.eq(InventoryDeductionDetailDO::getDeductionType, InventoryDeductionTypeEnum.INVENTORY_DETAIL_REFUND_TYPE.getCode());
  50.         List<InventoryDeductionDetailDO> inventoryDeductionDetailDOS = inventoryDetailMapper.selectList(queryWrapper);
  51.         return inventoryConverter.converterList(inventoryDeductionDetailDOS);
  52.     }
  54.     //保存库存扣减的明细
  55.     public void saveInventoryDetail(InventoryDetail inventoryDetail, Integer deductionType) throws DuplicateKeyException {
  56.         InventoryDeductionDetailDO inventoryDeductionDetailDO = inventoryConverter.converterDO(inventoryDetail);
  57.         inventoryDeductionDetailDO.setDeductionType(deductionType);
  58.         inventoryDeductionDetailDO.initCommon();
  59.         int count = inventoryDetailMapper.insert(inventoryDeductionDetailDO);
  60.         if (count <= 0) {
  61.             throw new BaseBizException(InventoryExceptionCode.INVENTORY_SQL);
  62.         }
  63.     }
  64.     ...
  65. }
复制代码
 
10.库存分桶回源扩容的Double Check
  1. @Service
  2. public class InventoryBucketServiceImpl implements InventoryBucketService {
  3.     ...
  4.     //分桶扩容接口
  5.     @Override
  6.     public void bucketCapacity(BucketCapacity bucketCapacity) {
  7.         //先锁住中心桶库存，避免此时库存发生变化
  8.         String key = TairInventoryConstant.SELLER_INVENTORY_LOCK_PREFIX + bucketCapacity.getSellerId() + bucketCapacity.getSkuId();
  9.         String value = SnowflakeIdWorker.getCode();
  10.         //1.校验是否已经无需扩容了，如果是则快速结束
  11.         BucketCapacityContext bucketCapacityContext = checkBucketCapacity(bucketCapacity);
  12.         if (!bucketCapacityContext.getIsCapacity()) {
  13.             return;
  14.         }
  15.         //获取分布式锁来进行扩容处理
  16.         boolean lock = tairLock.tryLock(key, value);
  17.         if (lock) {
  18.             try {
  19.                 //再次校验是否需要扩容，此处不允许并发
  20.                 bucketCapacityContext = checkBucketCapacity(bucketCapacity);
  21.                 if (bucketCapacityContext.getIsCapacity()) {
  22.                     //2.获取中心桶缓存的剩余库存
  23.                     Integer residueNum = getCenterStock(bucketCapacity);
  24.                     //3.可以扩容，计算出可回源的库存进行处理
  25.                     if (residueNum > 0) {
  26.                         backSourceInventory(residueNum, bucketCapacityContext);
  27.                     } else {
  28.                         //4.中心桶无库存，检查是否触发下线
  29.                         checkBucketOffline(bucketCapacity);
  30.                     }
  31.                 }
  32.             } catch (Exception e) {
  33.                 e.printStackTrace();
  34.             } finally {
  35.                 tairLock.unlock(key, value);
  36.             }
  37.         } else {
  38.             throw new BaseBizException("请求繁忙，稍后重试！");
  39.         }
  40.     }
  41.     ...
  42. }
复制代码
 
11.库存分桶扩容量计算算法实现
分桶需要扩容多少库存，需要注意尽量保证每个分桶的库存尽可能均匀。
 
如果中心桶库存超过最大深度库存，则直接以配置的回源步长增长库存，否则汇总当前分桶的实际库存深度。也就是根据当前的可⽤分桶列表、中⼼桶库存、总的可⽤库存深度，计算出平均的⼀个可分配库存数量。从而避免每个分桶扩容的库存不均匀(最⼩值必须超过最⼩库存深度)。
 
如果扩容的库存深度超过当时分配的库存深度，且未超过最⼤库存深度，则以当前分配的实际库存更新当前分桶库存深度。
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private InventoryBucketCache inventoryBucketCache;
  6.     @Resource
  7.     private TairCache tairCache;
  8.     ...
  10.     //查询返回卖家的商品实际库存信息
  11.     private List<InventoryResponseDTO> queryInventoryCacheList(InventoryQueryRequest queryRequest) {
  12.         //1.获取组装查询的缓存key
  13.         List<String> skuIdList = queryRequest.getSkuIdList();
  14.         List<InventoryResponseDTO> inventoryResponseDTOList = new ArrayList<>();
  15.         for (String skuId : skuIdList) {
  16.             //商品库存的分桶元数据的缓存key
  17.             String cacheKey = queryRequest.getSellerId() + skuId;
  18.             //获取分桶元数据的缓存，先查本地缓存，再查远程缓存
  19.             BucketLocalCache bucketLocalCache = inventoryBucketCache.getBucketLocalCache(cacheKey);
  20.             if (Objects.isNull(bucketLocalCache)) {
  21.                 continue;
  22.             }
  24.             List<BucketCacheBO> availableList = bucketLocalCache.getAvailableList();
  25.             availableList.addAll(bucketLocalCache.getUndistributedList());
  26.             //获取存有库存值的缓存key
  27.             List<String> bucketList = availableList.stream().map(BucketCacheBO::getBucketNo).collect(Collectors.toList());
  28.             //将缓存中心桶剩余库存的缓存key添加到bucketList
  29.             String key = TairInventoryConstant.SELLER_INVENTORY_PREFIX + cacheKey;
  30.             bucketList.add(key);
  32.             //获取每个缓存key对应的库存值
  33.             List<String> bucketNumList = tairCache.mget(bucketList);
  34.             Integer inventoryNum = 0;
  35.             for (String bucketNum : bucketNumList) {
  36.                 if (!Objects.isNull(bucketNum)) {
  37.                     inventoryNum = inventoryNum + Integer.valueOf(bucketNum);
  38.                 }
  39.             }
  41.             //构建商品库存模型
  42.             InventoryResponseDTO inventoryResponseDTO = new InventoryResponseDTO();
  43.             inventoryResponseDTO.setSellerId(queryRequest.getSellerId());
  44.             inventoryResponseDTO.setSellerId(skuId);
  45.             inventoryResponseDTO.setInventoryNum(inventoryNum);
  46.             inventoryResponseDTOList.add(inventoryResponseDTO);
  47.         }
  48.         return inventoryResponseDTOList;
  49.     }
  50.     ...
  51. }
复制代码
 
12.库存分桶扩容完成以及分桶下线触发
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     ...
  4.     //构建接下来用于处理具体扣减库存时所需要的上下文对象
  5.     private BucketContext buildDeductProductStock(InventoryRequest request) {
  6.         //1.填充扣减库存相关请求信息的明细
  7.         InventoryDetail inventoryDetail = inventoryConverter.converterRequest(request);
  8.         //2.填充扣减库存的分桶相关信息
  9.         BucketContext bucketContext = buildDeductBucketList(request);
  10.         bucketContext.setInventoryDetail(inventoryDetail);
  11.         return bucketContext;
  12.     }
  14.     //填充扣减库存的分桶相关信息
  15.     private BucketContext buildDeductBucketList(InventoryRequest request) {
  16.         BucketContext context = new BucketContext();
  17.         //获取本地缓存的分桶元数据
  18.         BucketLocalCache bucketLocalCache = inventoryBucketCache.getBucketLocalCache(request.getSellerId() + request.getSkuId());
  19.         //获取本地缓存的分桶列表
  20.         List<BucketCacheBO> availableList = bucketLocalCache.getAvailableList();
  22.         //获取本次扣减请求对应的扣减次数，用来定位具体使用的分桶库存
  23.         Integer incrementCount = getIncrementCount(request);
  25.         //通过运算得到本次访问所需要定位的分桶，使用Round Robin轮询算法
  26.         int index = incrementCount % availableList.size();
  28.         //获取本次准备处理的分桶信息
  29.         BucketCacheBO bucketCacheBO = availableList.get(index);
  30.         context.getAvailableList().add(bucketCacheBO);
  31.         context.getBucketNoList().add(bucketCacheBO.getBucketNo());
  33.         //获取分桶配置信息
  34.         context.setInventoryBucketConfig(bucketLocalCache.getInventoryBucketConfig());
  36.         //为了避免扣减失败(分桶已下线或者库存不足)，可以多备份几个分桶
  37.         for (int i = 0; i < 2; i++) {
  38.             //任意填充2个作为备份
  39.             Random random = new Random();
  40.             int num = random.nextInt(availableList.size());
  42.             BucketCacheBO bucketCache = availableList.get(num);
  43.             //避免拿到重复的分桶，这里处理一下
  44.             if (context.getBucketNoList().contains(bucketCache.getBucketNo())) {
  45.                 i--;
  46.                 continue;
  47.             }
  48.             context.getAvailableList().add(bucketCache);
  49.             context.getBucketNoList().add(bucketCache.getBucketNo());
  50.         }
  51.         return context;
  52.     }
  54.     //获取对应售卖商品的扣减访问次数
  55.     private Integer getIncrementCount(InventoryRequest request) {
  56.         String incrementKey = TairInventoryConstant.SELLER_SKU_STOCK_COUNT_PREFIX + request.getSellerId() + request.getSkuId();
  57.         Integer incrementCount = tairCache.incr(incrementKey);
  58.         return incrementCount;
  59.     }
  60.     ...
  61. }
复制代码
 
13.库存分桶下线以及剩余存量归还中心桶
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  5.     ...
  7.     //扣减库存
  8.     //@param bucketContext 库存扣减上下文对象
  9.     private void deductInventory(BucketContext bucketContext) {
  10.         //获取可以使用的分桶编号，即对应缓存中的key
  11.         List<String> bucketNoList = bucketContext.getBucketNoList();
  12.         //获取扣减明细信息
  13.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  14.         //获取扣减库存数量
  15.         Integer inventoryNum = inventoryDetail.getInventoryNum();
  16.         //获取用于处理扩容的Map
  17.         Map<String, Integer> capacityMap = bucketContext.getCapacityMap();
  18.         Boolean isDeduct = false;
  19.         //对分桶进行库存扣减(每次)
  20.         for (String bucketNo : bucketNoList) {
  21.             //自减，默认扣减后不能小于0，否则返回-1
  22.             Integer residueNum = tairCache.decr(bucketNo, inventoryNum);
  23.             //capacityMap可用于判断分桶是否是扩容的分桶，以及标记当前分桶剩余的库存数
  24.             capacityMap.put(bucketNo, residueNum);
  25.             //库存扣减成功
  26.             if (residueNum >= 0) {
  27.                 //标记一下具体扣减的分桶属于哪个
  28.                 inventoryDetail.setBucketNo(bucketNo);
  29.                 isDeduct = true;
  30.                 break;
  31.             }
  32.         }
  33.         //分桶扣减都没有成功，此时抛出异常提示库存不足
  34.         if (!isDeduct) {
  35.             throw new BaseBizException(InventoryExceptionCode.INVENTORY_INSUFFICIENT_ERROR);
  36.         }
  37.     }
  38.     ...
  39. }
复制代码
 
14.库存下线触发剩余库存总量预警机制
  1. @Service
  2. public class InventoryServiceImpl implements InventoryService {
  3.     @Resource
  4.     private TairCache tairCache;
  6.     @Resource
  7.     private InventoryDetailProducer inventoryDetailProducer;
  8.     ...
  10.     //将库存明细写入缓存(写入失败则代表已经被写入了，此时需要回退库存)
  11.     private void writeInventoryDetail(BucketContext bucketContext) {
  12.         //获取扣减明细信息
  13.         InventoryDetail inventoryDetail = bucketContext.getInventoryDetail();
  14.         String key = TairInventoryConstant.SELLER_SKU_TRADE_DETAIL_PREFIX + bucketContext.getInventoryDetail().getSellerId();
  15.         //尝试写入明细记录，如果没有写入成功则说明库存需要回退
  16.         Integer count = tairCache.exhset(key, String.valueOf(inventoryDetail.getOrderId()), JSONObject.toJSONString(inventoryDetail));
  17.         if (count < 0) {
  18.             //说明明细已经存在了，写入失败，此时需要将库存回退到对应的分桶上
  19.             tairCache.incr(inventoryDetail.getBucketNo(), inventoryDetail.getInventoryNum());
  20.         } else {
  21.             //发送消息，异步写入库存扣减的明细到DB
  22.             inventoryDetailProducer.sendInventoryDetail(bucketContext.getInventoryDetail());
  23.         }
  24.     }
  25.     ...
  26. }
  28. @Component
  29. public class TairCache {
  30.     private JedisPool jedisPool;
  32.     public TairCache(JedisPool jedisPool) {
  33.         this.jedisPool = jedisPool;
  34.     }
  36.     public Jedis getJedis() {
  37.         return jedisPool.getResource();
  38.     }
  40.     private TairHash createTairHash(Jedis jedis) {
  41.         return new TairHash(jedis);
  42.     }
  44.     //存储hash对象
  45.     public Integer exhset(String key,String field, String value){
  46.         try (Jedis jedis = getJedis()) {
  47.             return createTairHash(jedis).exhset(key, field, value, ExhsetParams.ExhsetParams().nx()).intValue();
  48.         }
  49.     }
  50. }
  52. //处理库存扣减明细的记录消息
  53. @Component
  54. public class InventoryDetailListener implements MessageListenerConcurrently {
  55.     @Resource
  56.     private InventoryRepository inventoryRepository;
  58.     @Override
  59.     public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
  60.         try {
  61.             log.info("执行库存扣减明细保存，消息数量：{}", list.size());
  62.             List<InventoryDetail> inventoryDetailList = new ArrayList<>(list.size());
  63.             for (MessageExt messageExt : list) {
  64.                 String msg = new String(messageExt.getBody());
  65.                 InventoryDetail inventoryDetail = JsonUtil.json2Object(msg, InventoryDetail.class);
  66.                 inventoryDetailList.add(inventoryDetail);
  67.             }
  68.             inventoryRepository.saveInventoryDetailList(inventoryDetailList, InventoryDeductionTypeEnum.INVENTORY_DETAIL_DEDUCTIONS_TYPE.getCode());
  69.         } catch (DuplicateKeyException ex) {
  70.             log.error("consume repeat, 库存扣减明细重复记录,不再重复执行", ex);
  71.             return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  72.         } catch (Exception e) {
  73.             log.error("consume error, 库存扣减明细保存失败", e);
  74.             //本次消费失败，下次重新消费
  75.             return ConsumeConcurrentlyStatus.RECONSUME_LATER;
  76.         }
  77.         return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  78.     }
  79. }
复制代码
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
厌外
2025-6-27 22:31:04

0

粉丝关注

13

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫