1、流程圖 1.1 數據預熱 1.2 搶購 1.3 生成訂單 (發送訂單消息) 1.4 訂單入庫 (監聽 消費訂單消息) 1.5 查看訂單狀態 1.6 支付 (獲取支付鏈接 ) 1.7 支付成功 微信回調 (發送 支付成功消息) 1.8 支付成功 返回給前端成功 (監聽 支付成功消息) 2、incr ...
1、流程圖
1.1 數據預熱
1.2 搶購
1.3 生成訂單 (發送訂單消息)
1.4 訂單入庫 (監聽 消費訂單消息)
1.5 查看訂單狀態
1.6 支付 (獲取支付鏈接 )
1.7 支付成功 微信回調 (發送 支付成功消息)
1.8 支付成功 返回給前端成功 (監聽 支付成功消息)
2、incr 和 setnx
2.1 incr
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 sexnx
Redis使用setnx命令實現分散式鎖;
2.1.1 加鎖
版本一#但是這種方式的缺點是容易產生死鎖，因為客戶端有可能忘記解鎖，或者解鎖失敗。
setnx key value
版本二#給鎖增加了過期時間，避免出現死鎖。但這兩個命令不是原子的，第二步可能會失敗，依然無法避免死鎖問題。
setnx key value
expire key seconds
版本三（推薦）#通過“set...nx...”命令，將加鎖、過期命令編排到一起，它們是原子操作了，可以避免死鎖。
set key value nx ex seconds
2.1.2 解鎖
解鎖就是刪除代表鎖的那份數據。
del key
參考博客：https://blog.csdn.net/weixin_45525272/article/details/126562119
3、實現代碼
主要是搶購的業務；
3.1模塊分析
3.2 web模塊
3.2.1 application.yml
點擊查看代碼
# 埠
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 # 鎖定商品庫存鎖頭標識
3.2.2 SeckillConfig 配置類
點擊查看代碼
/**
* Created On : 9/11/2022.
* <p>
* Author : huayu
* <p>
* 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;
}
3.2.3 搶購介面和實現類
3.2.3.1 介面
點擊查看代碼
/**
* Created On : 9/11/2022.
* <p>
* Author : huayu
* <p>
* 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);
}
3.2.3.2 實現類
點擊查看代碼
/**
* Created On : 9/11/2022.
* <p>
* Author : huayu
* <p>
* 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);
}
}
3.2.4 遠程調用訂單模塊進行下單
點擊查看代碼
/**
* Created On : 10/11/2022.
* <p>
* Author : huayu
* <p>
* 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);
}
3.2.5 搶購 控制層
點擊查看代碼
/**
* Created On : 9/11/2022.
* <p>
* Author : huayu
* <p>
* 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);
}
}
3.3 訂單模塊
3.3.1 application.yml
點擊查看代碼
# 埠
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 # 註冊中心的地址
3.3.2 OrderMQDirectConfig
點擊查看代碼
/**
* Created On : 1/11/2022.
* <p>
* Author : huayu
* <p>
* 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);
}
}
3.3.3 OrderMQConstant
點擊查看代碼
/**
* Created On : 1/11/2022.
* <p>
* Author : huayu
* <p>
* 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";
}
3.3.4 下訂單業務層
3.3.4.1 介面
點擊查看代碼
/**
* Created On : 10/11/2022.
* <p>
* Author : huayu
* <p>
* Description:
*/
public interface SeckillOrderService {
/**
* @author : huayu
* @date : 11/11/2022
* @param : [seckillOrder]
* @return : void
* @description : 生成秒殺訂單
*/
void saveSeckillOrder(Map<String,Object> seckillOrder);
}
3.3.4.2實現類
點擊查看代碼
/**
* Created On : 10/11/2022.
* <p>
* Author : huayu
* <p>
* Description: SeckillOrderServiceImpl
*/
@Service
@Slf4j
public class SeckillOrderServiceImpl implements SeckillOrderService {
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private RedisUtils redisUtils;
@Override
public void saveSeckillOrder(Map<String, Object> 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);
}
}
}
3.3.5 SeckillOrderSaveListener
點擊查看代碼
/**
* Created On : 1/11/2022.
* <p>
* Author : huayu
* <p>
* 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<String,Object> seckillOrder){
log.info("***** 秒殺搶購訂單：{}，開始入庫 ******",seckillOrder.get("seckillOrderNo"));
//TODO 將消息中的訂單實體對象，調入業務介面，插入到資料庫
redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),1);
log.info("***** 秒殺搶購訂單：{}，入庫成功 ******",seckillOrder.get("seckillOrderNo"));
}
}
3.3.6 下單 控制層
點擊查看代碼
/**
* Created On : 10/11/2022.
* <p>
* Author : huayu
* <p>
* 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<String, Object> 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();
}
}
3.4 查詢訂單狀態和訂單支付部分不再贅述
4、測試
4.1 初始化庫存
4.2 搶購
4.2.1 搶購情況
4.2.2 redis中數據變化情況
4.3 查看訂單詳情
4.4 訂單支付
支付的時候數註意穿透的路徑；
