防重复下单全攻略

// 生成幂等 Token（用户进入下单页时调用）
func GenerateToken(ctx context.Context, rdb *redis.Client, userToken string) (string, error) {
    token := uuid.New().String()
    key := fmt.Sprintf("idempotent:%s:%s", userToken, token)
    ok, err := rdb.SetNX(ctx, key, "1", 5*time.Minute).Result()
    if err != nil {
        return "", err
    }
    if !ok {
        return "", errors.New("生成 Token 失败")
    }
    return token, nil
}

// 校验 Token + 创建订单
func CreateOrder(ctx context.Context, rdb *redis.Client, userToken, token string, req OrderReq) error {
    // 1. GETDEL 原子消费 Token（取到值 = 首次提交，nil = 重复或过期）
    tokenKey := fmt.Sprintf("idempotent:%s:%s", userToken, token)
    val, err := rdb.GetDel(ctx, tokenKey).Result()
    if err != nil && err != redis.Nil {
        return err
    }
    if val == "" {
        return errors.New("请勿重复提交")
    }

    // 2. 业务维度防重锁
    bizKey := fmt.Sprintf("order:%s:%s:%s:%d:%d",
        req.MerchantID, req.CashierID, req.MemberID,
        req.Amount, time.Now().Unix()/5)
    locked, err := rdb.SetNX(ctx, bizKey, "1", 10*time.Second).Result()
    if err != nil {
        return err
    }
    if !locked {
        return errors.New("操作过于频繁，请稍后再试")
    }
    defer rdb.Del(ctx, bizKey)

    // 3. 创建订单
    return doCreateOrder(ctx, req)
}

func CreateOrder(ctx context.Context, db *sql.DB, req OrderReq) error {
    // request_id 由前端生成，放在 Header 或 Body 中
    _, err := db.ExecContext(ctx,
        `INSERT INTO orders (order_no, request_id, ...) VALUES (?, ?, ...)`,
        generateOrderNo(), req.RequestID)
    if isDuplicateKeyError(err) {
        return errors.New("请勿重复提交")
    }
    return err
}

func CreateOrder(ctx context.Context, rdb *redis.Client, req OrderReq) error {
    // 1. Redis SetNX 防重（request_id 由前端生成）
    lockKey := fmt.Sprintf("req_lock:%s", req.RequestID)
    ok, err := rdb.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
    if err != nil {
        return fmt.Errorf("Redis 操作失败: %w", err)
    }
    if !ok {
        return errors.New("请勿重复提交")
    }
    defer rdb.Del(ctx, lockKey)

    // 2. 创建订单
    return doCreateOrder(ctx, req)
}

// 签发
func GetSubmitToken(c *gin.Context) {
    token := uuid.NewString()
    IssueToken(token, "order")  // INSERT token, status='unused'
    c.JSON(200, gin.H{"token": token})
}

// 消费
func CreateOrder(c *gin.Context) {
    rows := ConsumeToken(token, "order")  // UPDATE status='used' WHERE status='unused'
    if rows == 0 {
        c.JSON(400, gin.H{"error": "请勿重复提交"})
        return
    }
    doCreateOrder(c)
}

func GetSubmitToken(bizType string) string {
    payload := fmt.Sprintf("%s.%s.%d", bizType, uuid.NewString(), time.Now().Unix())
    sig := hmacSHA256(getSecret(), payload)
    return payload + "." + sig  // 4段拼接，约100字符
}

func CheckAndRecord(token, bizType string) bool {
    parts := strings.SplitN(token, ".", 4)        // 1. 解析结构（必须是4段）
    if len(parts) != 4 { return false }

    if parts[0] != bizType { return false }        // 2. 业务类型匹配

    sig := hmacSHA256(getSecret(), strings.Join(parts[:3], "."))
    if !hmac.Equal([]byte(sig), []byte(parts[3])) {  // 3. HMAC 验签（常数时间比较）
        return false
    }

    ts, _ := strconv.ParseInt(parts[2], 10, 64)
    if time.Since(time.Unix(ts, 0)) > 30*time.Minute {  // 4. 有效期（30分钟）
        return false
    }

    return insertIdempotentKey(token)              // 5. INSERT 唯一索引（防同一 token 跨订单复用）
}