Go语言HTTP代理设置教程

在Go语言中，net/http包是进行HTTP通信的核心。当需要通过代理服务器发起HTTP请求时，net/http包提供了多种灵活的配置方式，以适应不同的应用场景。虽然没有直接的SetProxy方法，但可以通过以下几种机制来实现代理设置。

1. 通过环境变量配置代理

Go的net/http包在创建默认的http.Client时，会检查系统环境变量HTTP_PROXY和HTTPS_PROXY。如果这些变量被设置，默认的HTTP客户端将自动通过指定的代理发送请求。这种方法适用于需要全局应用代理的场景。

示例代码：

• 通过Shell环境设置：

  export HTTP_PROXY="http://proxyIp:proxyPort"
  # 对于HTTPS请求，也可以设置HTTPS_PROXY
  # export HTTPS_PROXY="http://proxyIp:proxyPort"

  一旦在Shell中设置，所有从该Shell启动的Go程序（使用默认HTTP客户端）都将遵循此代理设置。

• 在Go程序内部设置：

  package main
  
  import (
      "fmt"
      "io"
      "net/http"
      "os"
  )
  
  func main() {
      // 在程序运行时设置环境变量
      // 替换为你的代理地址和端口，例如 "http://127.0.0.1:8888"
      os.Setenv("HTTP_PROXY", "http://proxyIp:proxyPort") 
  
      client := &http.Client{} // 使用默认客户端，它会读取环境变量
      resp, err := client.Get("http://example.com")
      if err != nil {
          fmt.Printf("请求失败: %v\n", err)
          return
      }
      defer resp.Body.Close()
  
      body, _ := io.ReadAll(resp.Body)
      fmt.Printf("响应状态码: %d\n", resp.StatusCode)
      fmt.Printf("响应内容片段: %s...\n", body[:100])
  
      // 清除环境变量（可选，避免影响后续操作）
      os.Unsetenv("HTTP_PROXY")
  }

优点： 配置简单，适用于全局代理需求。 缺点： 缺乏细粒度控制，所有使用默认http.Client的请求都会通过该代理。

2. 为特定HTTP客户端定制代理

当需要为不同的HTTP请求使用不同的代理，或者不希望依赖系统环境变量时，可以通过自定义http.Client的Transport字段来指定代理。这是最常用且推荐的灵活配置方式。

http.Client的Transport字段是一个http.RoundTripper接口，通常使用*http.Transport的实例。http.Transport结构体中有一个Proxy字段，它是一个函数，接收一个*http.Request并返回代理*url.URL。http.ProxyURL函数可以帮助我们方便地构造这个Proxy函数。

示例代码：

package main

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

func main() {
    // 1. 解析代理URL
    // 替换为你的代理地址和端口，例如 "http://127.0.0.1:8888"
    proxyStr := "http://proxyIp:proxyPort" 
    proxyURL, err := url.Parse(proxyStr)
    if err != nil {
        fmt.Printf("解析代理URL失败: %v\n", err)
        return
    }

    // 2. 创建自定义的Transport
    // http.ProxyURL(proxyURL) 返回一个 func(*http.Request) (*url.URL, error)
    customTransport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
        // 可以在这里配置其他Transport参数，例如TLSClientConfig、DisableKeepAlives等
        MaxIdleConns:        100,
        IdleConnTimeout:     90 * time.Second,
        TLSHandshakeTimeout: 10 * time.Second,
        ExpectContinueTimeout: 1 * time.Second,
    }

    // 3. 创建带有自定义Transport的HTTP客户端
    myClient := &http.Client{
        Transport: customTransport,
        Timeout:   30 * time.Second, // 客户端请求超时设置
    }

    // 4. 使用该客户端发起请求
    resp, err := myClient.Get("http://example.com")
    if err != nil {
        fmt.Printf("请求失败: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Printf("响应状态码: %d\n", resp.StatusCode)
    fmt.Printf("响应内容片段: %s...\n", body[:100])

    // 示例：如果需要为另一个请求使用不同的代理或不使用代理，可以创建另一个客户端
    // noProxyClient := &http.Client{} // 使用默认Transport，可能受环境变量影响
    // resp2, err := noProxyClient.Get("http://another-example.com")
    // ...
}

优点： 提供了最灵活的代理配置方式，可以为每个http.Client实例指定不同的代理，互不影响。 缺点： 需要手动创建http.Transport和http.Client实例。

3. 修改默认传输层配置（全局影响）

在某些特定场景下，如果希望程序中所有的HTTP请求（包括使用http.Get、http.Post等快捷函数以及未指定Transport的http.Client）都通过同一个代理，可以直接修改http.DefaultTransport。

注意： 这种做法会影响整个程序的HTTP请求行为，应谨慎使用，并确保不会对其他模块造成意外影响。

示例代码：

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func init() {
    // 在程序启动时修改DefaultTransport
    // 替换为你的代理地址和端口，例如 "http://127.0.0.1:8888"
    proxyStr := "http://proxyIp:proxyPort" 
    proxyURL, err := url.Parse(proxyStr)
    if err != nil {
        fmt.Printf("解析代理URL失败: %v\n", err)
        // 实际应用中可能需要更完善的错误处理
        return
    }

    // 将DefaultTransport强制转换为*http.Transport类型进行修改
    // 确保DefaultTransport确实是*http.Transport类型
    if defaultTransport, ok := http.DefaultTransport.(*http.Transport); ok {
        defaultTransport.Proxy = http.ProxyURL(proxyURL)
        fmt.Println("已修改http.DefaultTransport以使用代理。")
    } else {
        // 如果DefaultTransport不是*http.Transport，则可能需要创建一个新的
        http.DefaultTransport = &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        }
        fmt.Println("已替换http.DefaultTransport以使用代理。")
    }
}

func main() {
    // 此时，所有使用http包默认行为的请求都会通过修改后的代理
    resp, err := http.Get("http://example.com") // 使用默认客户端
    if err != nil {
        fmt.Printf("请求失败: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Printf("响应状态码: %d\n", resp.StatusCode)
    fmt.Printf("响应内容片段: %s...\n", body[:100])

    // 即使是新创建的没有指定Transport的客户端也会受影响
    client := &http.Client{}
    resp2, err := client.Get("http://another-example.com")
    if err != nil {
        fmt.Printf("第二个请求失败: %v\n", err)
        return
    }
    defer resp2.Body.Close()
    fmt.Printf("第二个请求响应状态码: %d\n", resp2.StatusCode)
}

优点： 能够以最便捷的方式影响整个程序的HTTP请求，无需修改大量现有代码。 缺点： 全局性影响可能导致难以调试的问题，不推荐在库或大型应用中使用。

注意事项与最佳实践

• 错误处理： 在解析代理URL时，url.Parse可能会返回错误，务必进行适当的错误处理。
• HTTPS代理： HTTP_PROXY环境变量通常也适用于HTTPS请求。如果需要为HTTPS单独指定代理，可以使用HTTPS_PROXY环境变量。在http.Transport中，Proxy函数对HTTP和HTTPS请求都有效。
• 代理认证： 如果代理服务器需要认证，可以在代理URL中包含用户名和密码，例如：http://user:password@proxyIp:proxyPort。
• 性能考量： 使用代理会引入额外的网络跳转和延迟，可能影响请求性能。在对性能敏感的应用中，应仔细评估代理的必要性。
• 优先级：
  1. 如果http.Client明确指定了Transport，则该Transport的Proxy设置具有最高优先级。
  2. 如果http.Client未指定Transport（即使用默认Transport），则Go会