深入理解Go HTTP客户端的“无法分配请求地址”错误与解决方案

package main

import (
    "log"
    "net/http"
    "net/url"
    "time" // 导入time包用于设置超时
)

// 假设的后端服务地址
const backendURL = "http://127.0.0.1:8080/test"

func main() {
    proxyHandler := http.HandlerFunc(proxyHandlerFunc)
    log.Fatal(http.ListenAndServe("0.0.0.0:9000", proxyHandler))
}

func proxyHandlerFunc(w http.ResponseWriter, r *http.Request) {
    // 调整请求URL，指向后端服务
    u, err := url.Parse(backendURL)
    if err != nil {
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        log.Printf("Error parsing backend URL: %v", err)
        return
    }
    r.URL = u
    r.RequestURI = "" // 清除RequestURI，因为它通常不应发送给后端

    // 创建一个通道来接收响应
    c := make(chan *http.Response, 1) // 缓冲区为1，防止goroutine阻塞
    go doRequest(c)

    resp := <-c // 等待doRequest完成
    if resp != nil {
        // 错误处理：将后端响应写入到原始响应
        err := resp.Write(w)
        if err != nil {
            log.Printf("Error writing response: %v", err)
        }
        // ⚠️ 关键点：这里缺少对resp.Body的完整读取和关闭
        // resp.Body.Close() // 即使调用了Close，如果未完全读取，连接可能也无法复用
    } else {
        http.Error(w, "Backend service unavailable", http.StatusBadGateway)
    }
}

func doRequest(c chan *http.Response) {
    // 每次请求都创建一个新的客户端，这本身不是最佳实践
    // 但在这里是为了模拟问题，即使是新的客户端也可能受连接池影响
    client := &http.Client{
        Timeout: 10 * time.Second, // 设置超时
    }

    resp, err := client.Get(backendURL)
    if err != nil {
        log.Printf("Error making request to backend: %v", err)
        c <- nil
    } else {
        c <- resp
    }
}

import (
    "io"
    "io/ioutil" // ioutil.ReadAll 在 Go 1.16+ 中已弃用，推荐使用 io.ReadAll
    "log"
    "net/http"
)

// closeResponse 确保响应体被完全读取并关闭，以便连接可以复用。
// 如果有未读字节，它会打印日志，帮助调试。
func closeResponse(response *http.Response) error {
    if response == nil || response.Body == nil {
        return nil
    }

    // 尝试读取所有剩余的响应体内容
    // 注意：Go 1.16+ 推荐使用 io.ReadAll
    bs, err := io.ReadAll(response.Body)
    if err != nil {
        log.Printf("Error during ReadAll for connection reuse: %v", err)
        // 即使读取失败，也尝试关闭Body
        return response.Body.Close()
    }

    // 如果有未读字节，打印日志（可选，用于调试）
    if len(bs) > 0 {
        log.Printf("Had to read %d bytes for connection reuse. This is usually okay, but if unexpected, check client logic.", len(bs))
    }

    // 最后关闭响应体
    return response.Body.Close()
}

func doRequest(c chan *http.Response) {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get(backendURL)
    if err != nil {
        log.Printf("Error making request to backend: %v", err)
        c <- nil
        return // 错误时直接返回
    }

    // 确保在函数退出前关闭响应体，无论成功与否
    // 注意：这里先将resp发送到通道，然后通过defer确保关闭。
    // 但如果接收方需要处理resp.Body，那么关闭操作应在接收方完成。
    // 更安全的做法是，在将resp发送到通道前，先处理好body的读取和关闭。
    // 或者，将关闭逻辑放在proxyHandlerFunc中，在resp.Write(w)之后。

    c <- resp // 将响应发送到通道

    // ⚠️ 修正：如果resp.Body需要在proxyHandlerFunc中被读取和写入，
    // 那么doRequest不应该在此处关闭它。
    // 关闭的责任应该在proxyHandlerFunc中，在resp.Write(w)之后。
    // 但为了演示doRequest的独立性，我们在此处展示如何确保连接复用。
    // 在实际代理场景中，通常会在proxyHandlerFunc中处理resp.Body。
    // 让我们将关闭逻辑移到proxyHandlerFunc中，以适应代理模式。
}

// 修正后的proxyHandlerFunc
func proxyHandlerFunc(w http.ResponseWriter, r *http.Request) {
    u, err := url.Parse(backendURL)
    if err != nil {
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        log.Printf("Error parsing backend URL: %v", err)
        return
    }
    r.URL = u
    r.RequestURI = ""

    c := make(chan *http.Response, 1)
    go doRequestForProxy(c) // 使用一个专门为代理设计的doRequest

    resp := <-c
    if resp != nil {
        defer closeResponse(resp) // 确保响应体被完全读取并关闭

        // 将后端响应头复制到原始响应
        for k, v := range resp.Header {
            w.Header()[k] = v
        }
        w.WriteHeader(resp.StatusCode)

        // 将后端响应体复制到原始响应
        _, err := io.Copy(w, resp.Body)
        if err != nil {
            log.Printf("Error copying response body: %v", err)
        }
    } else {
        http.Error(w, "Backend service unavailable", http.StatusBadGateway)
    }
}

// doRequestForProxy 专门为代理服务设计，不负责关闭resp.Body
func doRequestForProxy(c chan *http.Response) {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get(backendURL)
    if err != nil {
        log.Printf("Error making request to backend: %v", err)
        c <- nil
    } else {
        c <- resp
    }
}

import (
    "io"
    "net/http"
)

// 在proxyHandlerFunc中，当从后端获取到resp后：
func proxyHandlerFunc(w http.ResponseWriter, r *http.Request) {
    // ... (前面的URL解析和请求转发逻辑)

    c := make(chan *http.Response, 1)
    go doRequestForProxy(c)

    resp := <-c
    if resp != nil {
        // 确保在函数退出前关闭响应体
        // 如果你只需要状态码或头部，而不需要响应体内容，可以使用io.Copy丢弃
        defer func() {
            _, err := io.Copy(io.Discard, resp.Body) // 丢弃所有未读字节
            if err != nil {
                log.Printf("Error discarding response body: %v", err)
            }
            err = resp.Body.Close() // 然后关闭Body
            if err != nil {
                log.Printf("Error closing response body after discard: %v", err)
            }
        }()

        // ... (处理响应头和状态码)

        // 如果需要将后端响应体传递给客户端，则不能丢弃，应使用io.Copy(w, resp.Body)
        // 如果不需要，这里可以不进行io.Copy(w, resp.Body)操作
        // 但由于是代理，通常需要将后端响应体传回给原始客户端
        // 所以在代理场景下，io.Copy(w, resp.Body) 会同时完成读取和写入
        // 此时，defer io.Copy(io.Discard, resp.Body) 就不需要了，因为io.Copy(w, resp.Body)
        // 已经读取了全部内容。但仍需要 defer resp.Body.Close()

        // 代理场景下的正确处理：
        for k, v := range resp.Header {
            w.Header()[k] = v
        }
        w.WriteHeader(resp.StatusCode)
        _, err := io.Copy(w, resp.Body) // 这会读取并写入所有内容
        if err != nil {
            log.Printf("Error copying response body to client: %v", err)
        }
        // io.Copy完成后，resp.Body已经读完，只需关闭
        // defer closeResponse(resp) 或 defer resp.Body.Close() 放在这里更合适
        // 但因为在函数开始处已经有了defer，所以它会在函数返回前执行
    } else {
        http.Error(w, "Backend service unavailable", http.StatusBadGateway)
    }
}