public OrderConfirmVO confirmOrder(Long skuId) {
Long memberId = SecurityUtils.getMemberId();
// 解決子線程無(wú)法獲取HttpServletRequest請(qǐng)求對(duì)象中數(shù)據(jù)的問(wèn)題,子線程指getOrderItemsFuture，getMemberAddressFuture，generateOrderTokenFuture
//feign遠(yuǎn)程調(diào)用會(huì)被攔截提取attributes并轉(zhuǎn)發(fā)
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
RequestContextHolder.setRequestAttributes(attributes, true);
// 獲取訂單商品
//使用了 CompletableFuture 來(lái)實(shí)現(xiàn)異步執(zhí)行獲取訂單項(xiàng)的操作
CompletableFuture<List<OrderItemDTO>> getOrderItemsFuture = CompletableFuture.supplyAsync(
	() -> this.getOrderItems(skuId, memberId), threadPoolExecutor)
.exceptionally(ex -> {
	log.error("Failed to get order items: {}", ex.toString());
	return null;
});
// 用戶收貨地址
CompletableFuture<List<MemberAddressDTO>> getMemberAddressFuture = CompletableFuture.supplyAsync(() -> {
	Result<List<MemberAddressDTO>> getMemberAddressResult = memberFeignClient.listMemberAddresses(memberId);
	if (Result.isSuccess(getMemberAddressResult)) {
		return getMemberAddressResult.getData();
	}
	return null;
}, threadPoolExecutor).exceptionally(ex -> {
	log.error("Failed to get addresses for memberId {} : {}", memberId, ex.toString());
	return null;
});
// 生成唯一令牌,防止重復(fù)提交(原理：提交會(huì)消耗令牌，令牌被消耗無(wú)法再次提交)
CompletableFuture<String> generateOrderTokenFuture = CompletableFuture.supplyAsync(() -> {
	String orderToken = this.generateTradeNo(memberId);
	redisTemplate.opsForValue().set(OrderConstants.ORDER_TOKEN_PREFIX + orderToken, orderToken);
	return orderToken;
}, threadPoolExecutor).exceptionally(ex -> {
	log.error("Failed to generate order token .");
	return null;
});
//CompletableFuture.allOf 方法，可以等待所有 CompletableFuture 對(duì)象都完成再進(jìn)行后續(xù)操作，
// 確保獲取和設(shè)置屬性的操作都能夠成功執(zhí)行。這樣可以避免程序出現(xiàn)異常，
CompletableFuture.allOf(getOrderItemsFuture, getMemberAddressFuture, generateOrderTokenFuture).join();
OrderConfirmVO orderConfirmVO = new OrderConfirmVO();
orderConfirmVO.setOrderItems(getOrderItemsFuture.join());
orderConfirmVO.setAddresses(getMemberAddressFuture.join());
orderConfirmVO.setOrderToken(generateOrderTokenFuture.join());
log.info("Order confirm response for skuId {}: {}", skuId, orderConfirmVO);
return orderConfirmVO;
}

  private String generateTradeNo(Long memberId) {
  //當(dāng) memberId 的位數(shù)小于 5 位時(shí)，使用 0 來(lái)填充位數(shù)不足的部分，如果 memberId 已經(jīng)是 5 位數(shù)或更長(zhǎng)，則不進(jìn)行填充
  String userIdFilledZero = String.format("%05d", memberId);
  //超出五位的保留后五位
  String fiveDigitsUserId = userIdFilledZero.substring(userIdFilledZero.length() - 5);
  // 在前面加上wxo（wx order）等前綴是為了人工可以快速分辨訂單號(hào)是下單還是退款、來(lái)自哪家支付機(jī)構(gòu)等
  // 將時(shí)間戳+3位隨機(jī)數(shù)+五位id組成商戶訂單號(hào)，規(guī)則參考自<a  rel="external nofollow" >大眾點(diǎn)評(píng)</a>
  return System.currentTimeMillis() + RandomUtil.randomNumbers(3) + fiveDigitsUserId;
  }

  /**
   * 自定義訂單線程池
   *
   */
  @Configuration
  @Slf4j
  public class ThreadPoolConfig {
  	@Bean
  	public ThreadPoolExecutor threadPoolExecutor() {
  		int cpuCoreSize = Runtime.getRuntime().availableProcessors();//使用 Java 獲取可用的 CPU 核心數(shù)
  		log.info("當(dāng)前CPU核心數(shù):{}", cpuCoreSize);
  		/*
  		 * 計(jì)算密集型: 核心線程數(shù)=CPU核心 +1   √
  		 * I/O密集型: 核心線程數(shù)=2*CPU核心 +1
  		 */
  		int corePoolSize = cpuCoreSize + 1;
  		return new ThreadPoolExecutor(
  			 //核心線程數(shù)
  				corePoolSize,
  				//最大線程數(shù)
  				2 * corePoolSize,
  				//線程空閑(存活)時(shí)間;當(dāng)線程數(shù)超過(guò)核心線程數(shù)，并且空閑時(shí)間超過(guò)指定時(shí)間時(shí)，多余的線程會(huì)被銷(xiāo)毀
  				30,
  				TimeUnit.SECONDS,
  				//任務(wù)隊(duì)列(選取數(shù)組阻塞隊(duì)列）特點(diǎn)：固定容量，公平性，先進(jìn)先出
  				new ArrayBlockingQueue<>(1000),
  				//線程工廠
  				new NamedThreadFactory("order") // 訂單線程
  		);
  	}
  }

@GlobalTransactional
public String submitOrder(OrderSubmitForm submitForm) {
log.info("訂單提交參數(shù):{}", JSONUtil.toJsonStr(submitForm));
String orderToken = submitForm.getOrderToken();
// 1. 判斷訂單是否重復(fù)提交(LUA腳本保證獲取和刪除的原子性，成功返回1，否則返回0)
//KEYS[1]指OrderConstants.ORDER_TOKEN_PREFIX + orderToken，ARGV[1]指orderToken
String lockAcquireScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
//這一行代碼使用RedisTemplate的execute方法執(zhí)行Lua腳本。通過(guò)new DefaultRedisScript<>創(chuàng)建一個(gè)Redis腳本對(duì)象，并指定腳本字符串和返回結(jié)果的類(lèi)型（Long）。
// 然后使用Collections.singletonList來(lái)創(chuàng)建包含鎖鍵名和訂單令牌參數(shù)的列表，傳遞給execute方法。
//執(zhí)行 Redis 腳本后，結(jié)果會(huì)賦值給 lockAcquired 變量，它的類(lèi)型是 Long。
// lockAcquired這個(gè)值表示獲取鎖的結(jié)果，如果成功獲取并刪除了鎖，則為 1；如果獲取鎖失敗，則為 0。
Long lockAcquired = this.redisTemplate.execute(
	new DefaultRedisScript<>(lockAcquireScript, Long.class),
	Collections.singletonList(OrderConstants.ORDER_TOKEN_PREFIX + orderToken),
orderToken
);
Assert.isTrue(lockAcquired != null && lockAcquired.equals(1L), "訂單重復(fù)提交，請(qǐng)刷新頁(yè)面后重試");
// 2. 訂單商品校驗(yàn) (PS：校驗(yàn)進(jìn)入訂單確認(rèn)頁(yè)面到提交過(guò)程商品(價(jià)格、上架狀態(tài))變化)
List<OrderSubmitForm.OrderItem> orderItems = submitForm.getOrderItems();
List<Long> skuIds = orderItems.stream()
.map(OrderSubmitForm.OrderItem::getSkuId)
.collect(Collectors.toList());
List<SkuInfoDTO> skuList = skuFeignClient.getSkuInfoList(skuIds);
for (OrderSubmitForm.OrderItem item : orderItems) {
	SkuInfoDTO skuInfo = skuList.stream().filter(sku -> sku.getId().equals(item.getSkuId()))
	.findFirst()
	.orElse(null);
	Assert.isTrue(skuInfo != null, "商品({})已下架或刪除");
	//如果調(diào)用對(duì)象小于被比較對(duì)象，compareTo 方法返回一個(gè)負(fù)整數(shù)。
	// 如果調(diào)用對(duì)象大于被比較對(duì)象，compareTo 方法返回一個(gè)正整數(shù)。
	Assert.isTrue(item.getPrice().compareTo(skuInfo.getPrice()) == 0, "商品({})價(jià)格發(fā)生變動(dòng)，請(qǐng)刷新頁(yè)面", item.getSkuName());
}
// 3. 校驗(yàn)庫(kù)存并鎖定庫(kù)存
List<LockedSkuDTO> lockedSkuList = orderItems.stream()
.map(item -> new LockedSkuDTO(item.getSkuId(), item.getQuantity(), item.getSkuSn()))
.collect(Collectors.toList());
boolean lockStockResult = skuFeignClient.lockStock(orderToken, lockedSkuList);
Assert.isTrue(lockStockResult, "訂單提交失?。烘i定商品庫(kù)存失??！");
// 4. 生成訂單
boolean result = this.saveOrder(submitForm);
log.info("order ({}) create result:{}", orderToken, result);
return orderToken;
}

@Transactional
public boolean lockStock(String orderToken, List<LockedSkuDTO> lockedSkuList) {
	Assert.isTrue(CollectionUtil.isNotEmpty(lockedSkuList), "訂單({})未包含任何商品", orderToken);
	// 校驗(yàn)庫(kù)存數(shù)量是否足夠以及鎖定庫(kù)存
	for (LockedSkuDTO lockedSku : lockedSkuList) {
		Long skuId = lockedSku.getSkuId();
		//商品分布式鎖緩存鍵前綴:ProductConstants.SKU_LOCK_PREFIX
		//每次getLock都會(huì)返回一個(gè)獨(dú)立的分布式鎖對(duì)象，但它們共享一個(gè)鎖資源。
		RLock lock = redissonClient.getLock(ProductConstants.SKU_LOCK_PREFIX + skuId);  // 構(gòu)建商品鎖對(duì)象
		try {
			//共享一個(gè)鎖資源意味著多個(gè)分布式鎖對(duì)象共同使用同一個(gè)鎖來(lái)實(shí)現(xiàn)互斥訪問(wèn)。
			//雖然每個(gè)分布式鎖對(duì)象是獨(dú)立創(chuàng)建的，但它們會(huì)使用相同的鎖資源來(lái)進(jìn)行加鎖和釋放鎖的操作。
			lock.lock();//鎖定操作
			Integer quantity = lockedSku.getQuantity(); // 訂單的商品數(shù)量
			// 庫(kù)存足夠
			boolean lockResult = this.update(new LambdaUpdateWrapper<PmsSku>()
											 .setSql("locked_stock = locked_stock + " + quantity) // 修改鎖定商品數(shù)
											 .eq(PmsSku::getId, lockedSku.getSkuId())
											 //通過(guò) apply 方法添加動(dòng)態(tài) SQL 條件，確保 stock 減去 locked_stock 的值大于等于給定的 quantity。
											 //使用了占位符 {0} 來(lái)引用 quantity,0表示第一個(gè)傳入的值。
											 .apply("stock - locked_stock >= {0}", quantity) // 剩余商品數(shù) ≥ 訂單商品數(shù)
											);
			Assert.isTrue(lockResult, "商品({})庫(kù)存不足", lockedSku.getSkuSn());
		} finally {
			if (lock.isLocked()) {
				lock.unlock();
			}
		}
	}
	// 鎖定的商品緩存至 Redis (后續(xù)使用：1.取消訂單解鎖庫(kù)存；2：支付訂單扣減庫(kù)存)
	redisTemplate.opsForValue().set(ProductConstants.LOCKED_SKUS_PREFIX + orderToken, lockedSkuList);
	return true;
}

/**
*解鎖庫(kù)存
*<P>
*訂單超時(shí)未支付，釋放鎖定的商品庫(kù)存
*/
public boolean unlockStock(String orderSn) {
//鎖定庫(kù)存對(duì)象集合：lockedSkus
	List<LockedSkuDTO> lockedSkus = (List<LockedSkuDTO>) redisTemplate.opsForValue().get(ProductConstants.LOCKED_SKUS_PREFIX + orderSn);
	log.info("釋放訂單({})鎖定的商品庫(kù)存:{}", orderSn, JSONUtil.toJsonStr(lockedSkus));
	// 庫(kù)存已釋放
	if (CollectionUtil.isEmpty(lockedSkus)) {
		return true;
	}
	// 遍歷恢復(fù)鎖定的商品庫(kù)存
	for (LockedSkuDTO lockedSku : lockedSkus) {
		RLock lock = redissonClient.getLock(ProductConstants.SKU_LOCK_PREFIX + lockedSku.getSkuId());  // 獲取商品分布式鎖
		try {
			lock.lock();
			this.update(new LambdaUpdateWrapper<PmsSku>()
						.setSql("locked_stock = locked_stock - " + lockedSku.getQuantity())
						.eq(PmsSku::getId, lockedSku.getSkuId())
					   );
		} finally {
			//判斷當(dāng)前分布式鎖是否已被鎖定，通過(guò)這個(gè)判斷可以防止非法釋放鎖等潛在問(wèn)題
			if (lock.isLocked()) {
				lock.unlock();
			}
		}
	}
	// 移除 redis 訂單鎖定的商品
	redisTemplate.delete(ProductConstants.LOCKED_SKUS_PREFIX + orderSn);
	return true;
}

   /**
	 * 扣減庫(kù)存
	 * <p>
	 * 訂單支付扣減商品庫(kù)存和釋放鎖定庫(kù)存
	 *
	 * @param orderSn 訂單編號(hào)
	 * @return ture/false
	 */
public boolean deductStock(String orderSn) {
	// 獲取訂單提交時(shí)鎖定的商品
	List<LockedSkuDTO> lockedSkus = (List<LockedSkuDTO>) redisTemplate.opsForValue().get(ProductConstants.LOCKED_SKUS_PREFIX + orderSn);
	log.info("訂單({})支付成功，扣減訂單商品庫(kù)存：{}", orderSn, JSONUtil.toJsonStr(lockedSkus));
	Assert.isTrue(CollectionUtil.isNotEmpty(lockedSkus), "扣減商品庫(kù)存失?。河唵?{})未包含商品");
	for (LockedSkuDTO lockedSku : lockedSkus) {
		RLock lock = redissonClient.getLock(ProductConstants.SKU_LOCK_PREFIX + lockedSku.getSkuId());    // 獲取商品分布式鎖
		try {
			lock.lock();
			this.update(new LambdaUpdateWrapper<PmsSku>()
					.setSql("stock = stock - " + lockedSku.getQuantity())
					.setSql("locked_stock = locked_stock - " + lockedSku.getQuantity())
					.eq(PmsSku::getId, lockedSku.getSkuId())
			);
		} finally {
			if (lock.isLocked()) {
				lock.unlock();
			}
		}
	}
	// 移除訂單鎖定的商品
	redisTemplate.delete(ProductConstants.LOCKED_SKUS_PREFIX + orderSn);
	return true;
}

/**
 * 創(chuàng)建訂單
 *
 * @param submitForm 訂單提交表單對(duì)象
 * @return
 */
private boolean saveOrder(OrderSubmitForm submitForm) {
//創(chuàng)建訂單詳情表(OmsOrder)對(duì)象
OmsOrder order = orderConverter.form2Entity(submitForm);
//設(shè)置待支付狀態(tài)
order.setStatus(OrderStatusEnum.UNPAID.getValue());
//設(shè)置訂單會(huì)員id
order.setMemberId(SecurityUtils.getMemberId());
//設(shè)置訂單來(lái)源(0代表PC訂單，1代表APP訂單)
order.setSource(submitForm.getOrderSource().getValue());
//保存到數(shù)據(jù)庫(kù)
boolean result = this.save(order);
Long orderId = order.getId();
if (result) {
	// 保存訂單明細(xì)
	List<OmsOrderItem> orderItemEntities = orderItemConverter.item2Entity(submitForm.getOrderItems());
	orderItemEntities.forEach(item -> item.setOrderId(orderId));
	orderItemService.saveBatch(orderItemEntities);
	// 訂單超時(shí)未支付取消
	//這行代碼使用 RabbitMQ 的 Java 客戶端庫(kù)來(lái)發(fā)送一條消息到 order.exchange 交換器，
	// 該消息會(huì)被路由到 order.close.delay 隊(duì)列中。消息的內(nèi)容是 submitForm.getOrderToken() 方法的返回結(jié)果。
	rabbitTemplate.convertAndSend("order.exchange", "order.close.delay", submitForm.getOrderToken());
}
return result;
}

@Component
@Slf4j
public class OrderRabbitConfig {
	// 普通延遲隊(duì)列
	private static final String ORDER_CLOSE_DELAY_QUEUE = "order.close.delay.queue";
	private static final String ORDER_EXCHANGE = "order.exchange";
	private static final String ORDER_CLOSE_DELAY_ROUTING_KEY = "order.close.delay";
	// 死信關(guān)單隊(duì)列
	private static final String ORDER_ClOSE_QUEUE = "order.close.queue";
	private static final String ORDER_DLX_EXCHANGE = "order.dlx.exchange";
	private static final String ORDER_ClOSE_ROUTING_KEY = "order.close";
	/**
	 * 定義交換機(jī)
	 */
	@Bean
	public Exchange orderExchange() {
		return new DirectExchange(ORDER_EXCHANGE, true, false);
	}
	/**
	 * 死信交換機(jī)
	 */
	@Bean
	public Exchange orderDlxExchange() {
		return new DirectExchange(ORDER_DLX_EXCHANGE, true, false);
	}
	/**
	 * 延時(shí)隊(duì)列
	 */
	@Bean
	public Queue orderDelayQueue() {
		// 延時(shí)隊(duì)列的消息過(guò)期了，會(huì)自動(dòng)觸發(fā)消息的轉(zhuǎn)發(fā)，根據(jù)routingKey發(fā)送到指定的exchange中，exchange路由到死信隊(duì)列
		Map<String, Object> args = new HashMap<>();
		args.put("x-dead-letter-exchange", ORDER_DLX_EXCHANGE);
		args.put("x-dead-letter-routing-key", ORDER_ClOSE_ROUTING_KEY); // 死信路由Key
		args.put("x-message-ttl", 10 * 1000L); // 單位毫秒，10s用于測(cè)試
		return new Queue(ORDER_CLOSE_DELAY_QUEUE, true, false, false, args);
	}
	/**
	 * 延時(shí)隊(duì)列綁定交換機(jī)
	 */
	@Bean
	public Binding orderDelayQueueBinding() {
		return new Binding(ORDER_CLOSE_DELAY_QUEUE, Binding.DestinationType.QUEUE, ORDER_EXCHANGE,
						   ORDER_CLOSE_DELAY_ROUTING_KEY, null);
	}
	/**
	 * 關(guān)單隊(duì)列
	 */
	@Bean
	public Queue orderCloseQueue() {
		log.info("死信隊(duì)列(order.close.queue)創(chuàng)建");
		return new Queue(ORDER_ClOSE_QUEUE, true, false, false);
	}
	/**
	 * 關(guān)單隊(duì)列綁定死信交換機(jī)
	 */
	@Bean
	public Binding orderCloseQueueBinding() {
		return new Binding(ORDER_ClOSE_QUEUE, Binding.DestinationType.QUEUE, ORDER_DLX_EXCHANGE,
						   ORDER_ClOSE_ROUTING_KEY, null);
	}
}

/**
 * 訂單超時(shí)未支付系統(tǒng)自動(dòng)取消監(jiān)聽(tīng)器
 *
 */
@Component
@RequiredArgsConstructor
@Slf4j
public class OrderCloseListener {
	private final OrderService orderService;
	private final RabbitTemplate rabbitTemplate;
	@RabbitListener(queues = "order.close.queue")
	public void closeOrder(String orderSn, Message message, Channel channel) {
		long deliveryTag = message.getMessageProperties().getDeliveryTag(); // 消息序號(hào)（消息隊(duì)列中的位置）
		log.info("訂單({})超時(shí)未支付，系統(tǒng)自動(dòng)關(guān)閉訂單", orderSn);
		try {
			boolean closeOrderResult = orderService.closeOrder(orderSn);
			log.info("關(guān)單結(jié)果：{}", closeOrderResult);
			if (closeOrderResult) {
				// 關(guān)單成功：釋放庫(kù)存
				//發(fā)送訂單號(hào)
				rabbitTemplate.convertAndSend("stock.exchange", "stock.unlock", orderSn);
			} else {
				// 關(guān)單失?。河唵我驯魂P(guān)閉，手動(dòng)ACK確認(rèn)并從隊(duì)列移除消息
				channel.basicAck(deliveryTag, false); // false: 不批量確認(rèn)，僅確認(rèn)當(dāng)前單個(gè)消息
			}
		} catch (Exception e) {
			// 關(guān)單異常：拒絕消息并重新入隊(duì)
			try {
				channel.basicReject(deliveryTag, true); //  true: 重新放回隊(duì)列
				// channel.basicReject(deliveryTag, false); // false: 直接丟棄消息 (TODO 定時(shí)任務(wù)補(bǔ)償)
			} catch (IOException ex) {
				log.error("訂單({})關(guān)閉失敗，原因：{}", orderSn, ex.getMessage());
			}
		}
	}
}

  public boolean closeOrder(String orderSn) {
  return this.update(new LambdaUpdateWrapper<OmsOrder>()
  				   .eq(OmsOrder::getOrderSn, orderSn)
  				   .eq(OmsOrder::getStatus, OrderStatusEnum.UNPAID.getValue())
  				   .set(OmsOrder::getStatus, OrderStatusEnum.CANCELED.getValue())
  				  );
  }

  /**
  *庫(kù)存釋放監(jiān)聽(tīng)器
  */
  @Component
  @Slf4j
  @RequiredArgsConstructor
  public class StockReleaseListener {
  	private final SkuService skuService;
  	private static final String STOCK_UNLOCK_QUEUE = "stock.unlock.queue";
  	private static final String STOCK_EXCHANGE = "stock.exchange";
  	private static final String STOCK_UNLOCK_ROUTING_KEY = "stock.unlock";
  	@RabbitListener(bindings =
  					@QueueBinding(
  						value = @Queue(value = STOCK_UNLOCK_QUEUE,durable = "true"),
  						exchange = @Exchange(value = STOCK_EXCHANGE),
  						key = {STOCK_UNLOCK_ROUTING_KEY}
  					),
  					ackMode = "MANUAL")//手動(dòng)ACK
  	@RabbitHandler
  	public void UnlockStock(String orderSn, Message message, Channel channel){
  		log.info("訂單{}取消釋放庫(kù)存",orderSn);
  		long deliverTag=message.getMessageProperties().getDeliveryTag();
  		try{
  			skuService.unlockStock(orderSn);
  			channel.basicAck(deliverTag,false);
  		}catch (Exception e){
  			try {
  				channel.basicAck(deliverTag,true);
  			}catch (IOException ex){
  				log.error("訂單{}關(guān)閉失敗，原因：{}",orderSn,ex.getMessage());
  			}
  		}
  	}
  }

@GlobalTransactional
public <T> T payOrder(OrderPaymentForm paymentForm) {
	String orderSn = paymentForm.getOrderSn();
	OmsOrder order = this.getOne(new LambdaQueryWrapper<OmsOrder>().eq(OmsOrder::getOrderSn, orderSn));
	Assert.isTrue(order != null, "訂單不存在");
	Assert.isTrue(OrderStatusEnum.UNPAID.getValue().equals(order.getStatus()), "訂單不可支付，請(qǐng)檢查訂單狀態(tài)");
	RLock lock = redissonClient.getLock(OrderConstants.ORDER_LOCK_PREFIX + order.getOrderSn());
	try {
		lock.lock();
		T result;
		switch (paymentForm.getPaymentMethod()) {
			case WX_JSAPI:
				result = (T) wxJsapiPay(paymentForm.getAppId(), order.getOrderSn(), order.getPaymentAmount());
				break;
			default:
				result = (T) balancePay(order);
				break;
		}
		return result;
	} finally {
		//釋放鎖
		if (lock.isLocked()) {
			lock.unlock();
		}
	}
}