Golang API中不同端点返回相同结果的问题如何解决

这是一个典型的缓存或数据共享问题，很可能是由于在包级别或全局作用域中共享了可变数据导致的。以下是最常见的几种情况和解决方案：

1. 检查全局变量或包级变量

最常见的问题是使用了全局变量来存储请求结果：

// ❌ 错误示例：全局变量导致数据共享
var cachedResponse []byte
var responseMutex sync.Mutex

func GetDataHandler(w http.ResponseWriter, r *http.Request) {
    responseMutex.Lock()
    defer responseMutex.Unlock()
    
    if cachedResponse == nil {
        // 调用外部API
        resp, _ := http.Get("https://external-api.com/data")
        body, _ := io.ReadAll(resp.Body)
        cachedResponse = body
    }
    
    w.Header().Set("Content-Type", "application/json")
    w.Write(cachedResponse) // 所有请求都返回相同数据
}

解决方案：使用局部变量或请求上下文：

// ✅ 正确示例：每个请求独立处理
func GetDataHandler(w http.ResponseWriter, r *http.Request) {
    // 每个请求都重新获取数据
    resp, err := http.Get("https://external-api.com/data")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    w.Header().Set("Content-Type", "application/json")
    w.Write(body)
}

2. 检查HTTP客户端复用

如果复用了HTTP客户端且未正确重置请求，可能导致相同响应：

// ❌ 错误示例：复用请求对象
var client = &http.Client{}
var req *http.Request

func CallExternalAPI(endpoint string) ([]byte, error) {
    if req == nil {
        req, _ = http.NewRequest("GET", "https://external-api.com/"+endpoint, nil)
    } else {
        req.URL, _ = url.Parse("https://external-api.com/" + endpoint)
    }
    
    resp, err := client.Do(req)
    // ... 处理响应
}

解决方案：为每个请求创建新的Request对象：

// ✅ 正确示例：每次创建新请求
var client = &http.Client{
    Timeout: 30 * time.Second,
}

func CallExternalAPI(endpoint string) ([]byte, error) {
    req, err := http.NewRequest("GET", "https://external-api.com/"+endpoint, nil)
    if err != nil {
        return nil, err
    }
    
    // 添加请求头
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    return io.ReadAll(resp.Body)
}

3. 检查中间件或包装函数

中间件可能缓存了响应：

// ❌ 错误示例：中间件缓存了响应
func CachingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    var cache []byte
    var mu sync.Mutex
    
    return func(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        defer mu.Unlock()
        
        if cache != nil {
            w.Write(cache)
            return
        }
        
        // 捕获响应
        rw := &responseWriter{ResponseWriter: w}
        next(rw, r)
        
        cache = rw.body
    }
}

type responseWriter struct {
    http.ResponseWriter
    body []byte
}

func (rw *responseWriter) Write(b []byte) (int, error) {
    rw.body = b
    return rw.ResponseWriter.Write(b)
}

4. 完整示例：正确的端点实现

package main

import (
    "encoding/json"
    "io"
    "net/http"
    "time"
    
    "github.com/gorilla/mux"
)

type APIHandler struct {
    client *http.Client
}

func NewAPIHandler() *APIHandler {
    return &APIHandler{
        client: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

func (h *APIHandler) GetUserData(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID := vars["id"]
    
    // 每个请求独立调用外部API
    data, err := h.fetchFromExternalAPI("/users/" + userID)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(data)
}

func (h *APIHandler) GetProductData(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    productID := vars["id"]
    
    // 独立的调用，不会共享结果
    data, err := h.fetchFromExternalAPI("/products/" + productID)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(data)
}

func (h *APIHandler) fetchFromExternalAPI(path string) (map[string]interface{}, error) {
    req, err := http.NewRequest("GET", "https://external-api.com"+path, nil)
    if err != nil {
        return nil, err
    }
    
    // 为每个请求设置唯一标识
    req.Header.Set("X-Request-ID", time.Now().String())
    
    resp, err := h.client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    var result map[string]interface{}
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }
    
    return result, nil
}

func main() {
    r := mux.NewRouter()
    handler := NewAPIHandler()
    
    r.HandleFunc("/users/{id}", handler.GetUserData)
    r.HandleFunc("/products/{id}", handler.GetProductData)
    
    http.ListenAndServe(":8080", r)
}

5. 调试建议

添加日志来跟踪每个请求：

func (h *APIHandler) GetUserData(w http.ResponseWriter, r *http.Request) {
    requestID := time.Now().UnixNano()
    log.Printf("[%d] Starting GetUserData", requestID)
    
    // ... 处理逻辑
    
    log.Printf("[%d] Completed GetUserData", requestID)
}

检查是否在以下位置共享了数据：

1. 包级别变量
2. 单例模式的服务对象
3. HTTP客户端或请求对象的复用
4. 响应写入器的复用
5. 数据库连接或连接池的配置

问题通常出现在数据被意外共享，而不是并发问题。确保每个请求的处理流程都是独立的，不依赖前一个请求的状态。