SpringCloud(十一）- 秒殺 搶購
Redis Incr 命令将 key 中儲存的數字值增一。 如果 key 不存在，那麼 key 的值會先被初始化為 0 ，然後再執行 INCR 操作。且将key的有效時間設置為長期有效 。
2.1.1 常見使用場景 2.1.1.1 計數我們可能常會統計網站頁面每天訪問量，通過incr命令在redis中設置key，每次增加1，設置24小時過期。
2.1.1.2 限流日常的開放平台API一般常有限流，利用redis的incr命令可以實現一般的限流操作。如限制某接口每分鐘請求次數上限1000次
2.1.1.3 幂等MQ防止重複消費也可以利用INCR命令實現，如訂單防重，訂單5分鐘之内隻能被消費一次，訂單号作為redis的key
2.2 sexnxRedis使用setnx命令實現分布式鎖;
2.1.1 加鎖版本一#但是這種方式的缺點是容易産生死鎖，因為客戶端有可能忘記解鎖，或者解鎖失敗。
setnx key value
版本二#給鎖增加了過期時間，避免出現死鎖。但這兩個命令不是原子的，第二步可能會失敗，依然無法避免死鎖問題。
setnx key value
expire key seconds
版本三（推薦）#通過“set...nx...”命令，将加鎖、過期命令編排到一起，它們是原子操作了，可以避免死鎖。
set key value nx ex seconds
解鎖就是删除代表鎖的那份數據。
del key
參考博客：https://blog.csdn.net/weixin_45525272/article/details/126562119
3、實現代碼主要是搶購的業務；
3.1模塊分析
# 端口
server:
port: 8106
# 服務名
spring:
application:
name: edocmall-seckill-web
# redis 配置
redis:
host: 127.0.0.1
port: 6379
# eureka 注冊中心的配置
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:8096/eureka # 注冊中心的地址
# 秒殺搶購自定義配置
kh96:
seckill:
buy-user-count-prefix: seckill-buy-user-count # 請求用戶數量的限制頭标識
buy-prod-stock-count: 100 # 初始化腔骨商品的庫存數量，存入redis，實際開發中，沒有此配置(初始化商品庫存，在洗頭膏添加搶購商品是)
buy-prod-stock-prefix: seckill-buy-prod-stock # 搶購商品數量 頭标識
buy-user-lock-prefix: seckill-buy-user-lock # 鎖定搶購用戶的頭标識
buy-prod-lock-prefix: seckill-buy-prod-lock # 鎖定商品庫存鎖頭标識
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: SeckillConfig
*/
@Data
@Component
@ConfigurationProperties(prefix = "kh96.seckill")
public class SeckillConfig {
/*
請求用戶數量的限制頭标識
*/
private String buyUserCountPrefix;
/*
初始化搶購商品的庫存數量
*/
private Integer buyProdStockCount;
/*
搶購商品數量 頭标識
*/
private String buyProdStockPrefix;
/*
鎖定搶購用戶的頭标識
*/
private String buyUserLockPrefix;
/*
鎖定商品庫存鎖頭标識
*/
private String buyProdLockPrefix;
}
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: 秒殺搶購的業務接口
*/
public interface SeckillService {
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId, stockCount]
* @return : void
* @description : 初始化商品庫存到緩存
*/
boolean initProdStock2Redis(String prodId,Integer stockCount);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [productId]
* @return : boolean
* @description : 校驗搶購商品的請求數量是否達到上限
*/
boolean checkBuyUserCount(String productId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId, buyCount]
* @return : boolean
* @description : 校驗商品庫存是否充足
*/
boolean checkProdStockEnough(String prodId,Integer buyCount);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [userId, prodId]
* @return : boolean
* @description : 校驗用戶是否已經搶購過當前商品
*/
boolean checkBuyUserBought(String userId,String prodId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [userId]
* @return : boolean
* @description : 校驗商品庫存是否鎖定
*/
boolean checkProdStockLocked(String prodId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId]
* @return : boolean
* @description : 釋放庫存鎖
*/
void unLockProdStock(String prodId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId, butCount]
* @return : void
* @description : 扣減庫存
*/
void subProdStockCount(String prodId, Integer butCount);
}
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: 搶購業務接口實現類
*/
@Service
public class SeckillServiceImpl implements SeckillService {
@Autowired
private RedisUtils redisUtils;
@Autowired
private SeckillConfig seckillConfig;
@Override
public boolean initProdStock2Redis(String prodId, Integer stockCount) {
// 判斷redis中，是否存在已經初始化的商品庫存數據，如果已經存在，不需要再次初始化
if (ObjectUtils.isEmpty(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId))){
// 将商品庫存添加到redis中
return redisUtils.set(seckillConfig.getBuyProdStockPrefix() + ":" + prodId, stockCount);
}
// 已經存在商品庫存，不需要設置
return false;
}
@Override
public boolean checkBuyUserCount(String prodId) {
// 使用redis的incr操作，校驗當前商品的搶購用戶數是否達到上限
return redisUtils.incr(seckillConfig.getBuyUserCountPrefix() + ":" + prodId, 1)
> Integer.parseInt(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId).toString()) * 2;
}
@Override
public boolean checkProdStockEnough(String prodId, Integer buyCount) {
//校驗商品庫存，是否大于等于用戶搶購數量，如果小于，代表庫存不足
//TODO 如果redis 沒有查到庫存(庫存沒初始化，或者後台誤删，必須要進行數據庫查詢操作，獲取庫存，
// 要加鎖，隻有一個線程取操作)，再同步到redis
return Integer.parseInt(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId).toString())
>= buyCount;
}
@Override
public boolean checkBuyUserBought(String userId, String prodId) {
//使用redis的分布式鎖，sexnx,
// 如果上鎖成功，代表沒有買過，可以繼續購買,如果上鎖失敗，表示購買過不能繼續購買
//鎖時長為正搶購活動時長
return ! redisUtils.lock( seckillConfig.getBuyUserLockPrefix()+":"+userId,
null,
15*60); //模拟 搶購時長
}
@Override
public boolean checkProdStockLocked(String prodId) {
//使用redis的分布式鎖，sexnx,如果上鎖成功，代表庫存沒有被鎖，如果上鎖失敗代表庫存被其他用戶鎖定不能購買
//鎖庫存必須要增加時長限制，防止庫存鎖釋放失敗，導緻用戶無法搶購，過期仍然會釋放
return ! redisUtils.lock(seckillConfig.getBuyProdLockPrefix()+":"+prodId,
null,
2*60); //模拟鎖2分鐘
}
@Override
public void unLockProdStock(String prodId) {
//删除redis中的 庫存鎖
redisUtils.del(seckillConfig.getBuyProdLockPrefix()+":"+prodId);
}
@Override
public void subProdStockCount(String prodId, Integer butCount) {
//扣減 redis中緩存的商品庫存數量
//TODO redis緩存中操成功後，要發異步消息 到隊列 更新數據庫中商品庫存呢
redisUtils.decr(seckillConfig.getBuyProdStockPrefix() + ":" + prodId,
butCount);
}
}
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description: SeckillOrderFeignService
*/
@FeignClient(value = "edocmall-seckill-order")
public interface SeckillOrderFeignService {
/**
* @author : huayu
* @date : 10/11/2022
* @param : [userId, prodId, buyCount]
* @return : java.lang.String
* @description : 遠程調用訂單中心，生成秒殺搶購訂單的接口
*/
@GetMapping("/createSeckillOrder")
String feignInvokeCreateSeckillOrder(@RequestParam(value = "userId") String userId,
@RequestParam(value = "prodId") String prodId,
@RequestParam(value = "buyCount") Integer buyCount);
}
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: 秒殺操作入口
*/
@Slf4j
@RestController
@Api(tags = "秒殺操作")
public class SeckillController {
@Autowired
private SeckillService seckillService;
@Autowired
private SeckillOrderFeignService seckillOrderFeignService;
/**
* @author : zhukang
* @date : 2022/11/9
* @param : [userId, prodId, buyCount]
* @return : com.kgc.scd.util.RequestResult
* @description : 模拟初始化商品庫存，實際開發中，沒有此操作，是在後台添加搶購商品預熱是，直接同步到redis
*/
@GetMapping("/initProdStock")
@ApiOperation(value = "1 初始庫存", notes = "搶購商品預熱，初始化商品庫存數量到redis中")
@ApiImplicitParams({
@ApiImplicitParam(value = "初始化商品id",name = "prodId"),
@ApiImplicitParam(value = "初始化商品數量",name = "stockCount")
})
public RequestResult initProdStock(@RequestParam String prodId,
@RequestParam Integer stockCount){
log.info("------ 初始化商品：{}，庫存數量：{}，到redis緩存中 ------", prodId, stockCount);
// 增加業務邏輯處理：防止瞬時請求過多，使用redis的incr原子操作，進行請求用戶數的統計計數，如果請求已經達到了上限（比如：設定請求用戶數最多是搶購商品庫存的2倍），其它後續所有的請求都默認無效，返回失敗：當前請求用戶過多，請稍後重試
if(seckillService.initProdStock2Redis(prodId, stockCount)){
return ResultBuildUtil.success("初始化商品庫存成功！");
}
// 初始化商品庫存失敗
return ResultBuildUtil.fail("601", "初始化商品庫存失敗，請确認redis庫存是否已初始化！");
}
@GetMapping("/seckillBuy")
@ApiOperation(value = "2 開始秒殺", notes = "基于redis，RabbitMQ消息隊列，實現有序秒殺搶購功能")
@ApiImplicitParams({
@ApiImplicitParam(value = "用戶id",name = "userId"),
@ApiImplicitParam(value = "商品id",name = "prodId"),
@ApiImplicitParam(value = "搶購數量",name = "buyCount")
})
public RequestResult seckillBuy(@RequestParam String userId,
@RequestParam String prodId,
@RequestParam Integer buyCount){
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，開始搶購 ------", userId, prodId, buyCount);
// TODO 增加請求許可校驗（自定義注解+攔截器），校驗請求此接口的所有用戶是否是已登錄用戶，如果沒有登錄，提示請登錄
// TODO 增加接口參數的校驗，判斷用戶是否是系統正常用戶，不能是狀态異常用戶，判斷商品的數據是否正确（切記：涉及系統内數據不要信任請求參數，要信任系統的緩存的數據庫）
// TODO 為了提高搶購入口的并發處理能力，要減少數據庫交互，可以設計為根據商品編号，從redis緩存中查詢商品，如果商品信息存在，則參與搶購，如果不存在，還是需要到數據庫查詢商品，如果數據庫中存在，将商品信息存入redis緩存，如果數據庫不存在，則直接提示搶購失敗。
// TODO 此種場景，正常情況，沒有問題，可能存在的問題，某個商品，是首次參與搶購，緩存中沒有數據，但是數據庫有，雖然上面的處理方式，可以解決，但是在高并發場景下，同一時刻會有大批量的請求來秒殺此商品，此時同時去緩存中獲取商品數據，沒有獲取到，又同時去數據庫查詢，就會導緻數據庫扛不住壓力，可能直接數據庫挂掉。
// TODO 解決方式：緩存商品數據一般都是在後台添加搶購商品時，直接對商品進行預熱處理，即：事先把參與搶購的商品直接同步到redis緩存中，這樣當搶購開始，直接從redis緩存就可以獲取到商品，而不會出現緩存擊穿問題。
// TODO 雖然商品數據預熱方式，可以解決此類問題，但是可能還會存在例外（比如：緩存中的商品由于後台失誤操作，導緻設置的過期時間不對，緩存時間提前過期，或者緩存數據誤删除），此種情況還是需要當緩存不存在商品數據，從數據庫查詢，放入緩存的邏輯。
// TODO 解決方式：可以進行加鎖，限制在高并發的情況下訪問數據庫，如果同一時刻，緩存中沒有獲取到商品數據庫，就進入查詢數據庫操作，但是在進入查詢前，增加分布式鎖，隻有獲取到鎖的請求，才可以查詢數據庫并加入到緩存中（加完就釋放鎖），獲取不到鎖的請求，直接返回失敗（損失當前請求，後續請求進行彌補，隻要一個操作成功，緩存中的數據就存在，後續的請求自然可以獲取到數據）
// TODO 極端情況：redis無法使用，必須要增加redis的高可用，确保redis永遠是有效的，考慮的模式就是集群模式下的哨兵機制。或者把大批量的請求直接放到消息隊列，進行緩沖處理。
log.info("------------------------------ 進行請求用戶數的統計計數，防止請求過多 -----------------------------------------");
// 增加業務邏輯處理：防止瞬時請求過多，使用redis的incr原子操作，進行請求用戶數的統計計數，如果請求已經達到了上限（比如：設定請求用戶數最多是搶購商品庫存的2倍），其它後續所有的請求都默認無效，返回失敗：當前請求用戶過多，請稍後重試
if(seckillService.checkBuyUserCount(prodId)){
return ResultBuildUtil.fail("602", "搶購失敗，當前搶購用戶過多，請稍後重試！");
}
log.info("------------------------------ 查看庫存是否充足 -----------------------------------------");
//校驗商品庫存數量是否充足，可以進行後續搶購，日過不足,直接搶購失敗
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，庫存校驗 ------", userId, prodId, buyCount);
if(!seckillService.checkProdStockEnough(prodId,buyCount)){
//庫存不足，返回搶購失敗
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，庫存不足 ------", userId, prodId, buyCount);
return ResultBuildUtil.fail("603", "搶購失敗，庫存不足，缺貨！");
}
log.info("------------------------------ 判斷用戶是否搶購過 -----------------------------------------");
//增加幂等操作：當前搶購用戶隻能搶購一次，如果已經搶購過商品，不允許再次搶購(限制一個用戶同一個搶購商品，整個搶購期間隻能搶購一次)
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，鎖定搶購用戶,如果 已經搶購過商品，不允許再次搶購 ------", userId, prodId, buyCount);
if(seckillService.checkBuyUserBought(userId,prodId)){
//用戶搶購過，返回搶購失敗
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，重複搶購 ------", userId, prodId, buyCount);
return ResultBuildUtil.fail("604", "搶購失敗，重複搶購！");
}
log.info("------------------------------ 用戶獲取庫存鎖 -----------------------------------------");
//執行搶購業務，先給商品庫存上鎖(鎖庫存)，如果上鎖成功，代表當前用戶繼續搶購商品，如果上鎖失敗，說明有人搶購，進行等待
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，(嘗試獲取庫存鎖) 執行搶購業務，先給商品庫存上鎖(鎖庫存),拿到 庫存鎖 才可以開始下單 ------", userId, prodId, buyCount);
while (true){
//死循環，嘗試鎖庫存，如果鎖庫存成功，代表庫存所已經被釋放
if(!seckillService.checkProdStockLocked(prodId)){
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，鎖庫存成功，拿到 庫存鎖 ，開始下單------", userId, prodId, buyCount);
//結束循環，執行搶購下單
break;
}
log.debug("------ 用戶：{}，購買商品：{}，購買數量：{}，鎖庫存成功失敗,等待。。。------", userId, prodId, buyCount);
}
log.info("------------------------------ 已經獲得庫存鎖，再次判斷庫存是否充足 -----------------------------------------");
//考慮高并發的場景：
//多人同時校驗庫存成功，但是進入到搶購下單業務時，庫存呢隻夠部分人購買，需要再确定庫存是否足夠
//校驗商品庫存數量是否充足，可以進行後續搶購，日過不足,直接搶購失敗
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，鎖庫存後(拿到庫存鎖後) 再次 庫存校驗 ------",userId, prodId, buyCount);
if(!seckillService.checkProdStockEnough(prodId,buyCount)){
//釋放庫存鎖，後續用戶繼續嘗試購買
//庫存剩餘2兩，還有三個人買，庫存不足，後續兩個人各買一件
//釋放庫存鎖
seckillService.unLockProdStock(prodId);
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，再次 庫存校驗，庫存不足 ------", userId, prodId, buyCount);
//庫存不足，返回搶購失敗
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，搶購下單中，庫存不足 ------", userId, prodId, buyCount);
return ResultBuildUtil.fail("605", "搶購失敗，庫存不足，缺貨！");
}
log.info("------------------------------ 開始扣減庫存 -----------------------------------------");
//執行扣減商品庫存
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，扣減庫存 ------", userId, prodId, buyCount);
seckillService.subProdStockCount(prodId,buyCount);
log.info("------------------------------ 開始下單 -----------------------------------------");
//開始調用訂單中心的生成搶購訂單接口，下單并返回給前端，搶購結果
//先模拟下單成功，返回一個搶購訂單号
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，開始下單 ------", userId, prodId, buyCount);
// String seckillOrderNo = "SK"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
// + UUID.randomUUID().toString().substring(0,5);
String seckillOrder = seckillOrderFeignService.feignInvokeCreateSeckillOrder(userId, prodId, buyCount);
log.info("------------------------------ 下單成功 主動釋放庫存鎖 -----------------------------------------");
//生成搶購訂單成功，立刻釋放庫存鎖，給其他搶購用戶購買
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，下單成功，釋放庫存鎖 ------", userId, prodId, buyCount);
seckillService.unLockProdStock(prodId);
log.info("------ 用戶：{}，購買商品：{}，購買數量：{}，搶購成功 ------", userId, prodId, buyCount);
//返回搶購成功，實際開發不能返回此種格式的數據
//必須使用key和value的返回，方便前端獲取訂單号
return ResultBuildUtil.success("搶購成功，搶購訂單"+seckillOrder);
}
}
# 端口
server:
port: 8107
# 服務名
spring:
application:
name: edocmall-seckill-order
# redis
redis:
host: 127.0.0.1
port: 6379
# RabbitMQ
rabbitmq:
host: 1.117.75.57
port: 5672
username: admin
password: admin
# eureka 注冊中心的配置
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:8096/eureka # 注冊中心的地址
/**
* Created On : 1/11/2022.
*
* Author : huayu
*
* Description: Direct直連模式，自動配置類，自動創建隊列，交換機，并将隊列綁定到交換機，指定唯一路由
*/
@Configuration
public class OrderMQDirectConfig {
/**
* @author : huayu
* @date : 1/11/2022
* @param : []
* @return : org.springframework.amqp.core.Queue
* @description : directQueue
*/
@Bean
public Queue directQueue(){
return new Queue(OrderMQConstant.SECKILL_SAVE_ORDER_QUEUE_KH96,true);
}
/**
* @author : huayu
* @date : 1/11/2022
* @param : []
* @return : org.springframework.amqp.core.DirectExchange
* @description : 創建直連交換機
*/
@Bean
public DirectExchange directExchange(){
// 創建支持持久化的直連交換機，指定交換機的名稱
return new DirectExchange(OrderMQConstant.SECKILL_SAVE_ORDER_EXCHANGE_KH96U);
}
/**
* @author : huayu
* @date : 1/11/2022
* @param : []
* @return : org.springframework.amqp.core.Binding
* @description : 将直連隊列和直連交換機進行綁定，并指定綁定的唯一路由鍵
*/
@Bean
public Binding directBinding(){
// 将直連隊列和直連交換機進行綁定，并指定綁定的唯一路由鍵
return BindingBuilder.bind(directQueue())
.to(directExchange())
.with(OrderMQConstant.SECKILL_SAVE_ORDER_ROUTING_KH96);
}
}
/**
* Created On : 1/11/2022.
*
* Author : huayu
*
* Description: RabbitMQ 常量類，系統的所有隊列名，交換機名，路由鍵名等，統一進行配置管理
*/
public class OrderMQConstant {
//========================== 直連模式
/**
* Direct直連模式 隊列名
*/
public static final String SECKILL_SAVE_ORDER_QUEUE_KH96 ="seckill_save_order_queue_kh96";
/**
* Direct直連模式 交換機名
*/
public static final String SECKILL_SAVE_ORDER_EXCHANGE_KH96U ="seckill_save_order_exchange_kh96";
/**
* Direct直連模式 路由鍵
*/
public static final String SECKILL_SAVE_ORDER_ROUTING_KH96 ="seckill_save_order_routing_kh96";
//========================== 扇形模式
/**
* Fanout 扇形模式 隊列名
*/
public static final String ACCOUNT_FANOUT_QUEUE_KH96 ="account_pay_result_queue_kh96";
}
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description:
*/
public interface SeckillOrderService {
/**
* @author : huayu
* @date : 11/11/2022
* @param : [seckillOrder]
* @return : void
* @description : 生成秒殺訂單
*/
void saveSeckillOrder(Map seckillOrder);
}
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description: SeckillOrderServiceImpl
*/
@Service
@Slf4j
public class SeckillOrderServiceImpl implements SeckillOrderService {
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private RedisUtils redisUtils;
@Override
public void saveSeckillOrder(Map seckillOrder) {
//發送生成搶購訂單的消息到消息隊列，并在redis中添加此訂單的記錄，模拟交互
//0 正在生成
if(redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),0)){
//發送生成訂單的消息
rabbitTemplate.convertAndSend(OrderMQConstant.SECKILL_SAVE_ORDER_EXCHANGE_KH96U,
OrderMQConstant.SECKILL_SAVE_ORDER_ROUTING_KH96,
seckillOrder);
}
}
}
/**
* Created On : 1/11/2022.
*
* Author : huayu
*
* Description: Direct 直連模式消費者 One
*/
@Slf4j
@Component
//指定接聽的 消息隊列 名字
@RabbitListener(queues = OrderMQConstant.SECKILL_SAVE_ORDER_QUEUE_KH96)
public class SeckillOrderSaveListener {
@Autowired
private RedisUtils redisUtils;
/**
* @author : huayu
* @date : 1/11/2022
* @param : [directMsgJson]
* @return : void
* @description : Direct 直連模式消費者One,消費信息
*/
//指定消息隊列中的消息，交給對應的方法處理
@RabbitHandler
public void saveSeckillOrder(Map seckillOrder){
log.info("***** 秒殺搶購訂單：{}，開始入庫 ******",seckillOrder.get("seckillOrderNo"));
//TODO 将消息中的訂單實體對象，調入業務接口，插入到數據庫
redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),1);
log.info("***** 秒殺搶購訂單：{}，入庫成功 ******",seckillOrder.get("seckillOrderNo"));
}
}
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description: 秒殺搶購訂單入口
*/
@Slf4j
@RestController
public class SeckillOrderController {
@Autowired
private SeckillOrderService seckillOrderService;
/**
* @author : huayu
* @date : 10/11/2022
* @param : [userId, prodId, buyCount]
* @return : java.lang.String
* @description : 生成秒殺搶購訂單
*/
@GetMapping("/createSeckillOrder")
public String createSeckillOrder(@RequestParam String userId,
@RequestParam String prodId,
@RequestParam Integer buyCount){
log.info("****** 用戶：{}，購買商品：{}，購買數量：{}，生成搶購訂單 ******", userId, prodId, buyCount);
//TODO 必須要有參數校驗，必須要有用戶，商品信息的校驗，确定用戶是否正常，商品是否還在搶購中
//TODO 再次強調所有的中心模塊，數據來源，不能信任外部接口來源的參數，都必須從數據庫或者緩存中獲取，尤其是跟金錢相關
//TODO 所有的接口必需要校驗結束，通過獲取的數據，封裝訂單實體對象，用戶不關系訂單的生成業務，可以使用異步消息隊列，實現曉峰，并快速響應
//模拟生成一個搶購訂單号，并封裝成訂單實體對象，通過map集合模拟
String seckillOrderNo = "SK"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
+ UUID.randomUUID().toString().substring(0,5);
//創建訂單實體對象
Map seckillOrder = new HashMap<>();
seckillOrder.put("userId",userId);
seckillOrder.put("prodId",prodId);
seckillOrder.put("buyCount",buyCount);
//TODO 其他的訂單屬性封裝，比如收貨人，總價格，優惠，時間等
seckillOrder.put("seckillOrderNo",seckillOrderNo);
//發送到生成訂單的消息隊列中，使用異步處理
seckillOrderService.saveSeckillOrder(seckillOrder);
//返回搶購訂單
return seckillOrder.toString();
}
}
4.2.2 redis中數據變化情況
支付的時候數注意穿透的路徑；
以上是真正的電腦專家為你收集整理的SpringCloud(十一）- 秒殺 搶購的全部内容，希望文章能夠幫你解決所遇到的問題。
如果覺得真正的電腦專家網站内容還不錯，歡迎将真正的電腦專家推薦給好友。
最新文章
-
教你把脈知男女
8分鐘前 -
鄧中甲方劑學講稿—第四章清熱劑—清營涼血—犀角地黃湯
8分鐘前 -
北京頤和園：養雲軒探秘
9分鐘前 -
觀點引流大揭秘：如何用鮮明觀點，吸引高客單價用戶
10分鐘前 -
李辛最新采訪 | 孩子身心問題背後的原因（下）
21分鐘前 -
針家心悟：針灸如何取穴（純幹貨）
42分鐘前 -
有哪些非常實用的職場道理，是當了領導以後才明白的
60分鐘前 -
世界地理分區之歐洲篇
1小時前
熱門文章
-
威士忌高階關于 OB 與 IB，一次給你說透！
1天前 -
為什麼五點鐘要起床答案讓人吃驚！（現在知道還不晚）
1周前 -
美麗中國-2870：中國最大的内陸河，塔裡木河
3天前 -
老張老李侃門球之140篇
3天前 -
這個穴位可以治療多種胃痛腹痛，還可以減肥
1周前 -
診餘雜記（師傳經驗）
5天前 -
二十四山開門放水作竈真訣開門放水作竈直訣——子山
3天前 -
門球技巧 隻需五個字讓你打好門球
3天前
有話要說...