Go语言中实现大文件流式代理：高效转发与内存优化

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "time"
)

// proxyHandler 是一个 HTTP 处理函数，用于代理大文件
func proxyHandler(w http.ResponseWriter, r *http.Request) {
    // 假设我们要代理的文件URL
    // 实际应用中，这个URL可能来自请求参数或其他配置
    remoteFileURL := "http://example.com/large-file.zip" // 替换为实际的大文件URL

    // 创建一个新的HTTP请求到远程文件
    req, err := http.NewRequest(r.Method, remoteFileURL, r.Body)
    if err != nil {
        http.Error(w, "Error creating remote request", http.StatusInternalServerError)
        log.Printf("Error creating remote request: %v", err)
        return
    }

    // 复制客户端请求的头部到远程请求，例如User-Agent, Accept等
    // 注意：不应该复制所有头部，例如Connection, Content-Length等需要特殊处理
    for name, values := range r.Header {
        // 避免复制Hop-by-hop headers，这些头部是针对单次连接的
        if !isHopByHopHeader(name) {
            for _, value := range values {
                req.Header.Add(name, value)
            }
        }
    }

    // 执行远程请求
    client := &http.Client{
        Timeout: 30 * time.Second, // 设置一个合理的超时
    }
    resp, err := client.Do(req)
    if err != nil {
        http.Error(w, "Error fetching remote file", http.StatusBadGateway)
        log.Printf("Error fetching remote file: %v", err)
        return
    }
    defer resp.Body.Close() // 确保关闭远程响应体

    // 检查远程响应状态码
    if resp.StatusCode != http.StatusOK {
        http.Error(w, fmt.Sprintf("Remote server returned status: %s", resp.Status), resp.StatusCode)
        log.Printf("Remote server returned non-OK status: %s", resp.Status)
        return
    }

    // 复制远程响应的头部到客户端响应
    for name, values := range resp.Header {
        // 同样避免复制Hop-by-hop headers
        if !isHopByHopHeader(name) {
            for _, value := range values {
                w.Header().Add(name, value)
            }
        }
    }

    // 设置客户端响应状态码
    w.WriteHeader(resp.StatusCode)

    // 将远程响应体直接复制到客户端响应
    bytesCopied, err := io.Copy(w, resp.Body)
    if err != nil {
        // 注意：io.Copy在写入客户端时可能遇到网络中断，此时无法回滚HTTP响应头
        log.Printf("Error copying remote body to client: %v. Bytes copied: %d", err, bytesCopied)
        // 此时可能无法向客户端发送错误响应，因为部分数据可能已经发送
        // 实际处理中，可能需要记录日志并关闭连接
    } else {
        log.Printf("Successfully proxied file. Bytes copied: %d", bytesCopied)
    }
}

// isHopByHopHeader 检查一个HTTP头部是否是Hop-by-hop头部
// 这些头部不应该被代理转发，而是由连接的双方各自处理
func isHopByHopHeader(header string) bool {
    switch header {
    case "Connection", "Keep-Alive", "Proxy-Authenticate", "Proxy-Authorization",
        "Te", "Trailers", "Transfer-Encoding", "Upgrade":
        return true
    default:
        return false
    }
}

func main() {
    http.HandleFunc("/download", proxyHandler)
    log.Println("Proxy server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
)

// createProxyHandler 创建一个使用 httputil.ReverseProxy 的 HTTP 处理函数
func createProxyHandler(targetURL string) http.Handler {
    remote, err := url.Parse(targetURL)
    if err != nil {
        log.Fatalf("Failed to parse target URL: %v", err)
    }

    proxy := httputil.NewSingleHostReverseProxy(remote)

    // Director 函数用于修改发往远程服务器的请求
    // 可以在这里添加/修改请求头，例如添加认证信息
    proxy.Director = func(req *http.Request) {
        req.Header.Add("X-Forwarded-For", req.RemoteAddr) // 添加X-Forwarded-For头部
        req.Header.Add("X-Proxy-Agent", "Go-Reverse-Proxy")
        // 原始请求的Host头会被NewSingleHostReverseProxy自动设置为目标Host
        // 如果需要保留原始Host头，需要手动设置：req.Host = req.URL.Host
        req.URL.Scheme = remote.Scheme
        req.URL.Host = remote.Host
        // req.URL.Path = remote.Path + req.URL.Path // 如果需要拼接路径
    }

    // ModifyResponse 函数用于修改从远程服务器接收到的响应
    // 可以在这里修改响应头，例如移除某些敏感头部，或者添加CORS头部
    proxy.ModifyResponse = func(resp *http.Response) error {
        // 示例：移除响应中的Server头部
        resp.Header.Del("Server")
        // 示例：添加自定义响应头部
        resp.Header.Set("X-Proxied-By", "Go-Proxy-Service")
        return nil
    }

    // ErrorHandler 用于处理代理过程中发生的错误
    proxy.ErrorHandler = func(rw http.ResponseWriter, req *http.Request, err error) {
        log.Printf("Proxy error: %v for request %s %s", err, req.Method, req.URL.String())
        http.Error(rw, "Proxy Error: "+err.Error(), http.StatusBadGateway)
    }

    return proxy
}

func main() {
    // 替换为你的目标服务URL
    targetServiceURL := "http://example.com" // 代理到 example.com

    // 创建一个代理处理函数
    proxy := createProxyHandler(targetServiceURL)

    // 将代理处理函数挂载到 "/proxy/" 路径
    http.Handle("/proxy/", http.StripPrefix("/proxy/", proxy))

    log.Println("Reverse proxy server starting on :8080, proxying to", targetServiceURL)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"

    "github.com/go-martini/martini" // 假设已安装 Martini
)

// createMartiniProxyHandler 为 Martini 创建一个代理处理函数
func createMartiniProxyHandler(targetURL string) martini.Handler {
    remote, err := url.Parse(targetURL)
    if err != nil {
        log.Fatalf("Failed to parse target URL: %v", err)
    }

    proxy := httputil.NewSingleHostReverseProxy(remote)

    // 可以像之前一样配置Director, ModifyResponse, ErrorHandler
    proxy.Director = func(req *http.Request) {
        req.Header.Add("X-Forwarded-For", req.RemoteAddr)
        req.URL.Scheme = remote.Scheme
        req.URL.Host = remote.Host
    }
    proxy.ErrorHandler = func(rw http.ResponseWriter, req *http.Request, err error) {
        log.Printf("Martini proxy error: %v for request %s %s", err, req.Method, req.URL.String())
        http.Error(rw, "Martini Proxy Error: "+err.Error(), http.StatusBadGateway)
    }

    // Martini 的处理函数可以直接调用 proxy.ServeHTTP
    return func(w http.ResponseWriter, r *http.Request) {
        // 如果需要StripPrefix，可以在这里处理
        // 例如，如果Martini路由是 /api/download/*，而代理目标是 /
        // 则需要 r.URL.Path = strings.TrimPrefix(r.URL.Path, "/api/download")
        proxy.ServeHTTP(w, r)
    }
}

func main() {
    m := martini.Classic()

    targetServiceURL := "http://example.com" // 代理到 example.com

    // 将代理处理函数注册到 Martini 路由
    // 注意：Martini的路由匹配通常是精确的，如果需要匹配子路径，可以使用通配符
    m.Get("/download/**", createMartiniProxyHandler(targetServiceURL))

    log.Println("Martini proxy server starting on :3000, proxying to", targetServiceURL)
    log.Fatal(http.ListenAndServe(":3000", m))
}