<!-- 支付寶支付SDK -->
<dependency>
    <groupId>com.alipay.sdk</groupId>
    <artifactId>alipay-sdk-java</artifactId>
    <version>4.38.0.ALL</version> <!-- 版本可以選最新的，去Maven倉庫查就行 -->
</dependency>
<!-- 工具類：處理JSON（支付寶回調(diào)返回的是JSON） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version>
</dependency>
<!-- 日志：后面查問題要用到 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
</dependency>

server:
  port: 8080 # 項(xiàng)目端口，后面測試要用到
# 支付寶相關(guān)配置
alipay:
  app-id: 2021000000000000 # 你沙箱環(huán)境的APPID
  merchant-private-key: MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQ... # 你生成的商戶私鑰（完整的，包括開頭結(jié)尾）
  alipay-public-key: MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA... # 支付寶給你的公鑰（完整的）
  gateway-url: https://openapi.alipaydev.com/gateway.do # 沙箱網(wǎng)關(guān)（生產(chǎn)環(huán)境改正式網(wǎng)關(guān)）
  sign-type: RSA2 # 簽名類型，固定RSA2
  format: json # 參數(shù)格式，固定json
  charset: UTF-8 # 編碼，固定UTF-8

alipay:
  merchant-private-key: |
    -----BEGIN PRIVATE KEY-----
    MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQ...
    ...（中間省略）...
    -----END PRIVATE KEY-----

import com.alipay.api.AlipayApiException;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
import com.alipay.api.request.AlipayTradePagePayRequest;
import com.alipay.api.request.AlipayTradeQueryRequest;
import com.alipay.api.response.AlipayTradePagePayResponse;
import com.alipay.api.response.AlipayTradeQueryResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
 * 支付寶支付工具類
 * 咱把初始化、支付、查訂單的方法都放這
 */
@Slf4j
@Component
public class AlipayUtil {
    // 從配置文件讀取支付寶參數(shù)
    @Value("${alipay.app-id}")
    private String appId;
    @Value("${alipay.merchant-private-key}")
    private String merchantPrivateKey;
    @Value("${alipay.alipay-public-key}")
    private String alipayPublicKey;
    @Value("${alipay.gateway-url}")
    private String gatewayUrl;
    @Value("${alipay.sign-type}")
    private String signType;
    @Value("${alipay.format}")
    private String format;
    @Value("${alipay.charset}")
    private String charset;
    // 支付寶客戶端對象（初始化一次就行，不用每次調(diào)用都新建）
    private AlipayClient alipayClient;
    /**
     * 項(xiàng)目啟動時初始化AlipayClient
     * @PostConstruct：Spring加載完這個Bean后，自動執(zhí)行這個方法
     */
    @PostConstruct
    public void initAlipayClient() {
        alipayClient = new DefaultAlipayClient(
                gatewayUrl,
                appId,
                merchantPrivateKey,
                format,
                charset,
                alipayPublicKey,
                signType
        );
        log.info("支付寶客戶端初始化完成！appId：{}", appId);
    }
    /**
     * 發(fā)起電腦網(wǎng)站支付（最常用的，比如PC端點(diǎn)擊“支付寶支付”跳轉(zhuǎn)到支付寶頁面）
     * @param outTradeNo 商戶訂單號（自己生成，唯一，比如“ORDER20240520001”）
     * @param totalAmount 訂單金額（單位：元，比如1.00）
     * @param subject 訂單標(biāo)題（比如“測試訂單-20240520”）
     * @param returnUrl 支付成功后，支付寶跳轉(zhuǎn)回你的頁面（比如“http://localhost:8080/pay/success”）
     * @param notifyUrl 支付成功后，支付寶異步通知你的接口（比如“http://xxx.xxx.xxx.xxx:8080/pay/notify”）
     * @return 支付寶返回的HTML表單（前端渲染這個表單，就能跳轉(zhuǎn)到支付寶支付頁）
     */
    public String createPagePay(String outTradeNo, String totalAmount, String subject, String returnUrl, String notifyUrl) throws AlipayApiException {
        // 1. 創(chuàng)建支付請求對象（電腦網(wǎng)站支付用AlipayTradePagePayRequest）
        AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
        
        // 2. 設(shè)置回調(diào)地址
        request.setReturnUrl(returnUrl); // 同步回調(diào)（給用戶看的，跳轉(zhuǎn)用）
        request.setNotifyUrl(notifyUrl); // 異步回調(diào)（給后臺用的，真正處理訂單狀態(tài)的）
        
        // 3. 封裝支付參數(shù)（JSON格式）
        String bizContent = String.format(
                "{" +
                        "\"out_trade_no\":\"%s\"," +
                        "\"total_amount\":\"%s\"," +
                        "\"subject\":\"%s\"," +
                        "\"product_code\":\"FAST_INSTANT_TRADE_PAY\"" + // 產(chǎn)品碼，電腦網(wǎng)站支付固定這個
                "}",
                outTradeNo, totalAmount, subject
        );
        request.setBizContent(bizContent);
        log.info("發(fā)起支付寶支付請求！outTradeNo：{}，totalAmount：{}，bizContent：{}", outTradeNo, totalAmount, bizContent);
        // 4. 調(diào)用支付寶接口，獲取支付頁面HTML
        AlipayTradePagePayResponse response = alipayClient.pageExecute(request);
        
        // 5. 判斷請求是否成功（支付寶返回的code是10000表示成功）
        if (response.isSuccess()) {
            log.info("支付寶支付請求成功！outTradeNo：{}，支付寶交易號：{}", outTradeNo, response.getTradeNo());
            return response.getBody(); // 返回HTML表單，前端渲染后跳轉(zhuǎn)
        } else {
            log.error("支付寶支付請求失??！outTradeNo：{}，錯誤信息：{}", outTradeNo, response.getMsg());
            throw new AlipayApiException("支付寶支付請求失敗：" + response.getMsg());
        }
    }
    /**
     * 查詢訂單支付狀態(tài)（比如用戶付了錢，但同步回調(diào)沒跳回來，就查一下訂單是不是真的付了）
     * @param outTradeNo 商戶訂單號
     * @return 支付狀態(tài)（比如“TRADE_SUCCESS”表示支付成功）
     */
    public String queryTradeStatus(String outTradeNo) throws AlipayApiException {
        // 1. 創(chuàng)建查詢請求對象
        AlipayTradeQueryRequest request = new AlipayTradeQueryRequest();
        
        // 2. 封裝查詢參數(shù)
        String bizContent = String.format(
                "{" +
                        "\"out_trade_no\":\"%s\"" +
                "}",
                outTradeNo
        );
        request.setBizContent(bizContent);
        log.info("查詢支付寶訂單狀態(tài)！outTradeNo：{}，bizContent：{}", outTradeNo, bizContent);
        // 3. 調(diào)用查詢接口
        AlipayTradeQueryResponse response = alipayClient.execute(request);
        
        // 4. 處理查詢結(jié)果
        if (response.isSuccess()) {
            String tradeStatus = response.getTradeStatus();
            log.info("訂單查詢成功！outTradeNo：{}，支付狀態(tài)：{}，支付寶交易號：{}", outTradeNo, tradeStatus, response.getTradeNo());
            return tradeStatus;
        } else {
            log.error("訂單查詢失??！outTradeNo：{}，錯誤信息：{}", outTradeNo, response.getMsg());
            throw new AlipayApiException("訂單查詢失?。? + response.getMsg());
        }
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
 * 訂單服務(wù)（模擬）
 * 實(shí)際項(xiàng)目里這里要連數(shù)據(jù)庫，咱先用Map存
 */
@Slf4j
@Service
public class OrderService {
    // 模擬數(shù)據(jù)庫：key=商戶訂單號，value=訂單信息（用Map存訂單的各種字段）
    private static final Map<String, Map<String, String>> ORDER_MAP = new HashMap<>();
    /**
     * 創(chuàng)建訂單（生成唯一訂單號，存到Map里）
     * @param amount 訂單金額（元）
     * @param title 訂單標(biāo)題
     * @return 商戶訂單號
     */
    public String createOrder(String amount, String title) {
        // 1. 生成唯一商戶訂單號（用UUID，再截取一下，避免太長）
        String outTradeNo = "ORDER_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16);
        
        // 2. 封裝訂單信息
        Map<String, String> order = new HashMap<>();
        order.put("outTradeNo", outTradeNo);
        order.put("totalAmount", amount);
        order.put("subject", title);
        order.put("status", "WAIT_PAY"); // 訂單狀態(tài)：WAIT_PAY（待支付）、TRADE_SUCCESS（已支付）、CLOSED（已關(guān)閉）
        
        // 3. 存到“模擬數(shù)據(jù)庫”
        ORDER_MAP.put(outTradeNo, order);
        log.info("創(chuàng)建訂單成功！outTradeNo：{}，訂單信息：{}", outTradeNo, order);
        
        return outTradeNo;
    }
    /**
     * 更新訂單狀態(tài)（比如支付成功后，把狀態(tài)改成TRADE_SUCCESS）
     * @param outTradeNo 商戶訂單號
     * @param newStatus 新狀態(tài)
     * @return 是否更新成功
     */
    public boolean updateOrderStatus(String outTradeNo, String newStatus) {
        Map<String, String> order = ORDER_MAP.get(outTradeNo);
        if (order == null) {
            log.error("更新訂單狀態(tài)失?。∮唵尾淮嬖冢簕}", outTradeNo);
            return false;
        }
        // 記錄舊狀態(tài)，方便日志排查
        String oldStatus = order.get("status");
        order.put("status", newStatus);
        log.info("更新訂單狀態(tài)成功！outTradeNo：{}，舊狀態(tài)：{}，新狀態(tài)：{}", outTradeNo, oldStatus, newStatus);
        return true;
    }
    /**
     * 查詢訂單信息
     * @param outTradeNo 商戶訂單號
     * @return 訂單信息
     */
    public Map<String, String> getOrder(String outTradeNo) {
        return ORDER_MAP.get(outTradeNo);
    }
}

import com.alipay.api.AlipayApiException;
import com.xxx.pay.service.OrderService;
import com.xxx.pay.util.AlipayUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 支付相關(guān)接口
 */
@Slf4j
@RestController
@RequestMapping("/pay")
public class PayController {
    @Autowired
    private AlipayUtil alipayUtil;
    @Autowired
    private OrderService orderService;
    /**
     * 發(fā)起支付寶支付（前端調(diào)用這個接口，獲取跳轉(zhuǎn)鏈接）
     * @param amount 訂單金額（比如1.00）
     * @param title 訂單標(biāo)題（比如“測試訂單”）
     * @param response 用response把支付寶返回的HTML寫出去，前端直接跳轉(zhuǎn)
     */
    @GetMapping("/create")
    public void createPay(
            @RequestParam String amount,
            @RequestParam String title,
            HttpServletResponse response
    ) {
        try {
            // 1. 先創(chuàng)建訂單（生成商戶訂單號）
            String outTradeNo = orderService.createOrder(amount, title);
            
            // 2. 配置回調(diào)地址（注意：沙箱測試時，notifyUrl要能被外網(wǎng)訪問！后面講怎么解決）
            String returnUrl = "http://localhost:8080/pay/success"; // 同步回調(diào)：本地測試用localhost
            String notifyUrl = "http://xxx.xxx.xxx.xxx:8080/pay/notify"; // 異步回調(diào)：要外網(wǎng)能訪問的地址
            
            // 3. 調(diào)用支付寶工具類，獲取支付HTML
            String payHtml = alipayUtil.createPagePay(outTradeNo, amount, title, returnUrl, notifyUrl);
            
            // 4. 把HTML寫回前端（前端渲染后會自動跳轉(zhuǎn)到支付寶支付頁）
            response.setContentType("text/html;charset=UTF-8");
            PrintWriter out = response.getWriter();
            out.write(payHtml);
            out.flush();
            out.close();
            
        } catch (AlipayApiException e) {
            log.error("發(fā)起支付失??！金額：{}，標(biāo)題：{}", amount, title, e);
            throw new RuntimeException("支付發(fā)起失敗，請稍后再試");
        } catch (IOException e) {
            log.error("輸出支付HTML失敗！", e);
            throw new RuntimeException("支付頁面加載失敗，請稍后再試");
        }
    }
}

/**
 * 同步回調(diào)接口（支付成功后，支付寶跳回這里）
 * 注意：這個接口的參數(shù)名是固定的，支付寶會把訂單信息以GET參數(shù)的形式傳過來
 * @param outTradeNo 商戶訂單號
 * @param tradeNo 支付寶交易號
 * @param tradeStatus 支付狀態(tài)
 * @return 支付成功頁面（這里用字符串模擬，實(shí)際項(xiàng)目里返回HTML頁面）
 */
@GetMapping("/success")
public String paySuccess(
        @RequestParam String outTradeNo,
        @RequestParam String tradeNo,
        @RequestParam String tradeStatus
) {
    log.info("收到同步回調(diào)！outTradeNo：{}，tradeNo：{}，tradeStatus：{}", outTradeNo, tradeNo, tradeStatus);
    
    // 這里可以查一下訂單狀態(tài)，確認(rèn)是不是真的支付成功（防止偽造同步回調(diào)）
    Map<String, String> order = orderService.getOrder(outTradeNo);
    if (order == null) {
        log.error("同步回調(diào)：訂單不存在！outTradeNo：{}", outTradeNo);
        return "支付失敗：訂單不存在";
    }
    
    // 只有當(dāng)訂單狀態(tài)是TRADE_SUCCESS，才認(rèn)為是真的支付成功
    if ("TRADE_SUCCESS".equals(tradeStatus)) {
        return String.format("""
                <h1>支付成功啦！</h1>
                <p>訂單號：%s</p>
                <p>支付寶交易號：%s</p>
                <p>訂單金額：%s 元</p>
                <p>點(diǎn)擊<a href="http://localhost:8080">返回首頁</a></p>
                """, outTradeNo, tradeNo, order.get("totalAmount"));
    } else {
        log.warn("同步回調(diào)：支付狀態(tài)異常！outTradeNo：{}，tradeStatus：{}", outTradeNo, tradeStatus);
        return "支付狀態(tài)異常，請聯(lián)系客服";
    }
}

import com.alibaba.fastjson.JSONObject;
import com.alipay.api.internal.util.AlipaySignature;
import org.springframework.web.bind.annotation.PostMapping;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
/**
 * 異步回調(diào)接口（支付寶主動發(fā)請求到這里，處理訂單狀態(tài)）
 * 注意：這個接口必須是POST，且不能有登錄攔截（支付寶發(fā)請求不會帶token）
 */
@PostMapping("/notify")
public String payNotify(HttpServletRequest request) {
    try {
        // 1. 從request中獲取所有參數(shù)（支付寶會把訂單信息以POST參數(shù)的形式傳過來）
        Map<String, String> params = new HashMap<>();
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String name = parameterNames.nextElement();
            String value = request.getParameter(name);
            params.put(name, value);
        }
        log.info("收到異步回調(diào)請求！參數(shù)：{}", JSONObject.toJSONString(params));
        // 2. 驗(yàn)簽：驗(yàn)證這個請求是不是真的來自支付寶（關(guān)鍵！防止別人偽造回調(diào)）
        // 注意：要排除sign_type參數(shù)（支付寶驗(yàn)簽時不需要這個）
        String sign = params.get("sign");
        params.remove("sign_type");
        boolean verifyResult = AlipaySignature.rsaCheckV1(
                params,
                alipayPublicKey, // 支付寶公鑰（從配置文件拿，這里咱先直接用，后面優(yōu)化）
                charset, // 編碼
                signType // 簽名類型（RSA2）
        );
        // 3. 驗(yàn)簽失?。悍祷豧ail，支付寶會重試
        if (!verifyResult) {
            log.error("異步回調(diào)驗(yàn)簽失??！參數(shù)：{}", JSONObject.toJSONString(params));
            return "fail";
        }
        // 4. 驗(yàn)簽成功：處理訂單邏輯
        String outTradeNo = params.get("out_trade_no"); // 商戶訂單號
        String tradeStatus = params.get("trade_status"); // 支付狀態(tài)
        String totalAmount = params.get("total_amount"); // 支付金額（可以和訂單金額對比，防止篡改）
        // 4.1 先查訂單是否存在
        Map<String, String> order = orderService.getOrder(outTradeNo);
        if (order == null) {
            log.error("異步回調(diào)：訂單不存在！outTradeNo：{}", outTradeNo);
            return "fail"; // 返回fail，支付寶會重試（可能是訂單還沒創(chuàng)建好）
        }
        // 4.2 對比支付金額和訂單金額（防止別人改金額，比如訂單1元，實(shí)際付了0.1元）
        String orderAmount = order.get("totalAmount");
        if (!orderAmount.equals(totalAmount)) {
            log.error("異步回調(diào)：金額不匹配！outTradeNo：{}，訂單金額：{}，支付金額：{}", outTradeNo, orderAmount, totalAmount);
            return "fail";
        }
        // 4.3 根據(jù)支付狀態(tài)處理訂單（TRADE_SUCCESS表示支付成功）
        if ("TRADE_SUCCESS".equals(tradeStatus)) {
            // 4.3.1 檢查訂單當(dāng)前狀態(tài)：如果已經(jīng)是已支付，就不用再處理了（防止重復(fù)回調(diào)）
            if ("TRADE_SUCCESS".equals(order.get("status"))) {
                log.info("異步回調(diào)：訂單已處理過！outTradeNo：{}", outTradeNo);
                return "success"; // 返回success，告訴支付寶別再發(fā)了
            }
            // 4.3.2 處理核心邏輯：更新訂單狀態(tài)、扣庫存、發(fā)短信等（實(shí)際項(xiàng)目里這里要加事務(wù)）
            boolean updateResult = orderService.updateOrderStatus(outTradeNo, "TRADE_SUCCESS");
            if (updateResult) {
                log.info("異步回調(diào)：訂單處理成功！outTradeNo：{}，tradeStatus：{}", outTradeNo, tradeStatus);
                // 這里可以加其他邏輯：比如調(diào)用庫存服務(wù)扣庫存、調(diào)用短信服務(wù)發(fā)通知
                // stockService.reduceStock(outTradeNo);
                // smsService.sendPaySuccessSms(order.get("phone"));
                return "success"; // 處理成功，返回success
            } else {
                log.error("異步回調(diào)：更新訂單狀態(tài)失??！outTradeNo：{}", outTradeNo);
                return "fail"; // 返回fail，支付寶重試
            }
        } else if ("TRADE_CLOSED".equals(tradeStatus)) {
            // 訂單關(guān)閉（比如用戶超時未支付，支付寶關(guān)閉訂單）
            orderService.updateOrderStatus(outTradeNo, "CLOSED");
            log.info("異步回調(diào)：訂單已關(guān)閉！outTradeNo：{}", outTradeNo);
            return "success";
        }
        // 其他狀態(tài)（比如TRADE_PENDING，待支付）：不用處理，返回success
        log.info("異步回調(diào)：無需處理的狀態(tài)！outTradeNo：{}，tradeStatus：{}", outTradeNo, tradeStatus);
        return "success";
    } catch (Exception e) {
        log.error("異步回調(diào)處理異常！", e);
        return "fail"; // 出現(xiàn)異常，返回fail，支付寶重試
    }
}

/**
 * 查詢訂單支付狀態(tài)（給前端用，或者自己排查問題用）
 * @param outTradeNo 商戶訂單號
 * @return 訂單信息和支付狀態(tài)
 */
@GetMapping("/query")
public Map<String, String> queryOrder(@RequestParam String outTradeNo) {
    try {
        // 1. 先查本地訂單
        Map<String, String> order = orderService.getOrder(outTradeNo);
        if (order == null) {
            Map<String, String> result = new HashMap<>();
            result.put("code", "404");
            result.put("msg", "訂單不存在");
            return result;
        }

        // 2. 查支付寶那邊的支付狀態(tài)（如果本地是待支付，就查一下支付寶）
        if ("WAIT_PAY".equals(order.get("status"))) {
            String alipayStatus = alipayUtil.queryTradeStatus(outTradeNo);
            // 如果支付寶那邊已經(jīng)支付成功，就更新本地訂單狀態(tài)
            if ("TRADE_SUCCESS".equals(alipayStatus)) {
                orderService.updateOrderStatus(outTradeNo, "TRADE_SUCCESS");
                order.put("status", "TRADE_SUCCESS");
            }
            order.put("alipay_status", alipayStatus); // 加上支付寶的狀態(tài)
        }

        // 3. 返回訂單信息
        Map<String, String> result = new HashMap<>();
        result.put("code", "200");
        result.put("msg", "查詢成功");
        result.put("order", JSONObject.toJSONString(order));
        return result;

    } catch (AlipayApiException e) {
        log.error("查詢訂單失??！outTradeNo：{}", outTradeNo, e);
        Map<String, String> result = new HashMap<>();
        result.put("code", "500");
        result.put("msg", "查詢失?。? + e.getMessage());
        return result;
    }
}

// 新建一個解密處理器，項(xiàng)目啟動時解密私鑰
publicclass AlipayConfigDecryptProcessor implements EnvironmentPostProcessor {
    @Override
    publicvoid postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        // 從環(huán)境變量拿解密密鑰（別存在代碼里）
        String decryptKey = System.getenv("ALIPAY_DECRYPT_KEY");
        
        // 從配置里拿加密后的私鑰
        String encryptedPrivateKey = environment.getProperty("alipay.merchant-private-key");
        
        // 解密（這里用AES解密，實(shí)際項(xiàng)目里用更安全的算法）
        String decryptedPrivateKey = AESUtil.decrypt(encryptedPrivateKey, decryptKey);
        
        // 把解密后的私鑰放回環(huán)境變量
        Map<String, Object> map = new HashMap<>();
        map.put("alipay.merchant-private-key", decryptedPrivateKey);
        MapPropertySource source = new MapPropertySource("alipayDecryptSource", map);
        environment.getPropertySources().addFirst(source);
    }
}

// 在PayController里注入RedissonClient
@Autowired
private RedissonClient redissonClient;

// 異步回調(diào)接口里加鎖
@PostMapping("/notify")
public String payNotify(HttpServletRequest request) {
    String outTradeNo = null;
    RLock lock = null;
    try {
        // 前面的參數(shù)獲取、驗(yàn)簽代碼...
        outTradeNo = params.get("out_trade_no");
        
        // 加分布式鎖：鎖的key用訂單號，確保一個訂單只有一個線程處理
        lock = redissonClient.getLock("alipay:notify:lock:" + outTradeNo);
        boolean isLock = lock.tryLock(5, 30, TimeUnit.SECONDS); // 等待5秒，持有30秒
        if (!isLock) {
            log.warn("異步回調(diào)：獲取鎖失敗，可能有其他線程在處理！outTradeNo：{}", outTradeNo);
            return"fail"; // 返回fail，支付寶重試
        }
        
        // 加鎖成功后，再查一次訂單狀態(tài)（防止其他線程已經(jīng)處理了）
        Map<String, String> order = orderService.getOrder(outTradeNo);
        if ("TRADE_SUCCESS".equals(order.get("status"))) {
            return"success";
        }
        
        // 處理訂單邏輯...
        
    } catch (Exception e) {
        // 異常處理...
    } finally {
        // 釋放鎖（只有持有鎖的線程才能釋放）
        if (lock != null && lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
    return"success";
}