Golang如何实现接口幂等性设计 分享Token和去重表两种方案

package main

import (
    "fmt"
    "net/http"
    "github.com/google/uuid"
    "sync"
)

var (
    tokenStore = make(map[string]bool) // 简单示例，生产环境建议使用Redis
    mu         sync.Mutex
)

func generateToken() string {
    id := uuid.New()
    return id.String()
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    token := r.Header.Get("X-Idempotency-Token")
    if token == "" {
        http.Error(w, "Missing token", http.StatusBadRequest)
        return
    }

    mu.Lock()
    defer mu.Unlock()

    if _, ok := tokenStore[token]; ok {
        http.Error(w, "Duplicate request", http.StatusConflict)
        return
    }

    // 模拟业务逻辑
    fmt.Println("Processing request with token:", token)
    tokenStore[token] = true // 标记token为已使用

    fmt.Fprintln(w, "Request processed successfully")
}

func main() {
    http.HandleFunc("/", handleRequest)
    fmt.Println("Server listening on port 8080")
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "database/sql"
    "fmt"
    "net/http"

    _ "github.com/go-sql-driver/mysql" // 导入MySQL驱动
)

var db *sql.DB

func init() {
    // 替换为你的数据库连接信息
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname"
    var err error
    db, err = sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }
    if err := db.Ping(); err != nil {
        panic(err)
    }

    // 创建去重表 (如果不存在)
    _, err = db.Exec(`
        CREATE TABLE IF NOT EXISTS idempotency (
            request_id VARCHAR(255) PRIMARY KEY,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    `)
    if err != nil {
        panic(err)
    }
}

func handleRequestWithDeduplication(w http.ResponseWriter, r *http.Request) {
    requestId := r.URL.Query().Get("request_id") // 从请求参数中获取请求ID，实际情况可能更复杂

    if requestId == "" {
        http.Error(w, "Missing request_id", http.StatusBadRequest)
        return
    }

    // 尝试插入去重表
    _, err := db.Exec("INSERT IGNORE INTO idempotency (request_id) VALUES (?)", requestId)
    if err != nil {
        fmt.Println("Error inserting into idempotency table:", err)
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    // 检查是否插入成功
    rowsAffected, err := db.Exec("SELECT ROW_COUNT()")
    if err != nil {
        fmt.Println("Error getting row count:", err)
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }
    defer rowsAffected.Close()

    var count int
    err = rowsAffected.Scan(&count)
    if err != nil {
        fmt.Println("Error scanning row count:", err)
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    if count == 0 {
        // 重复请求
        fmt.Println("Duplicate request with request_id:", requestId)
        fmt.Fprintln(w, "Duplicate request")
        return
    }

    // 模拟业务逻辑
    fmt.Println("Processing request with request_id:", requestId)
    fmt.Fprintln(w, "Request processed successfully")
}

func main() {
    http.HandleFunc("/dedup", handleRequestWithDeduplication)
    fmt.Println("Server listening on port 8080")
    http.ListenAndServe(":8080", nil)
}