新品不限流量住宅代理:固定价格,流量不计量。 低至 $33.25/天

Go · 集成指南

如何在 Go 中使用代理

Go 使用代理无需任何第三方包:net/http 即可处理需要认证的 HTTP 和 SOCKS5 网关。本指南涵盖 IP 轮换、粘性会话、地理定位以及网关状态码的解读。

  • 共 6 步
  • 12 分钟完成配置
  • 复制即用的代码

开始之前

  • Go 1.20 或更高版本
  • 仅需标准库(net/http 和 net/url)
  • Proxonym 住宅代理或移动代理套餐
获取代理凭据

已是客户?您的用户名和密码就在控制台中。

  1. 创建模块

    本页的每个示例都是一个只使用标准库的 main.go 文件,因此只需新建一个模块即可。使用 go run . 运行每个示例。

    Shell
    mkdir proxydemo && cd proxydemo
    go mod init proxydemo
  2. 通过网关发送请求

    为 Transport 设置一个包含凭据的代理 URL。Go 会通过 Proxy-Authorization 请求头发送这些凭据,用于建立 HTTPS 隧道的 CONNECT 请求也不例外。

    Go
    package main
    
    import (
    	"fmt"
    	"io"
    	"log"
    	"net/http"
    	"net/url"
    	"time"
    )
    
    func main() {
    	proxyURL, err := url.Parse("http://USERNAME:PASSWORD@gw.proxonym.com:8000")
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	client := &http.Client{
    		Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    		Timeout:   60 * time.Second,
    	}
    
    	resp, err := client.Get("https://api.ipify.org")
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer resp.Body.Close()
    
    	ip, err := io.ReadAll(resp.Body)
    	if err != nil {
    		log.Fatal(err)
    	}
    	fmt.Println("Exit IP:", string(ip))
    }
  3. 轮换 IP 或保持同一 IP

    网关按连接分配 IP,而 http.Transport 会保持长连接(keep-alive)。禁用 keep-alive 即可让每个请求都获得新 IP;也可以保持启用,并添加 -session- ID,将同一 IP 最长保持 120 分钟。

    Go
    package main
    
    import (
    	"crypto/rand"
    	"encoding/hex"
    	"fmt"
    	"io"
    	"net/http"
    	"net/url"
    	"strings"
    	"time"
    )
    
    // proxonymClient adds parameters such as "country-us" or "session-a7k2" to the username.
    func proxonymClient(keepAlive bool, params ...string) *http.Client {
    	user := strings.Join(append([]string{"USERNAME"}, params...), "-")
    	proxyURL := &url.URL{
    		Scheme: "http",
    		User:   url.UserPassword(user, "PASSWORD"),
    		Host:   "gw.proxonym.com:8000",
    	}
    	return &http.Client{
    		Transport: &http.Transport{
    			Proxy:             http.ProxyURL(proxyURL),
    			DisableKeepAlives: !keepAlive,
    		},
    		Timeout: 60 * time.Second,
    	}
    }
    
    func newSessionID() string {
    	b := make([]byte, 4)
    	rand.Read(b)
    	return hex.EncodeToString(b)
    }
    
    func exitIP(client *http.Client) string {
    	resp, err := client.Get("https://api.ipify.org")
    	if err != nil {
    		return "error: " + err.Error()
    	}
    	defer resp.Body.Close()
    	body, _ := io.ReadAll(resp.Body)
    	return string(body)
    }
    
    func main() {
    	// Rotating: keep-alives off, so each request opens a new connection and gets a new IP
    	rotating := proxonymClient(false, "country-us")
    	for i := 0; i < 3; i++ {
    		fmt.Println("rotating", exitIP(rotating))
    	}
    
    	// Sticky: one session ID keeps the same IP for up to 30 minutes
    	sticky := proxonymClient(true, "country-us", "session-"+newSessionID(), "lifetime-30")
    	for i := 0; i < 3; i++ {
    		fmt.Println("sticky", exitIP(sticky))
    	}
    }
  4. 定位国家、州、城市或 ASN

    将位置参数传给上一步中的 proxonymClient()。使用小写的 ISO 国家代码,空格用下划线代替,州和城市二选一,不要同时指定。

    Go
    clients := map[string]*http.Client{
    	"California": proxonymClient(true, "country-us", "state-california"),
    	"London":     proxonymClient(true, "country-gb", "city-london"),
    	"Comcast":    proxonymClient(true, "country-us", "asn-7922"),
    }
    
    for name, client := range clients {
    	resp, err := client.Get("https://ipinfo.io/json")
    	if err != nil {
    		fmt.Println(name, "error:", err)
    		continue
    	}
    	body, _ := io.ReadAll(resp.Body)
    	resp.Body.Close()
    	fmt.Println(name, string(body))
    }
  5. 使用 SOCKS5 端点

    net/http 也支持带用户名和密码的 socks5:// 代理 URL。主机名会以未解析的形式发送给代理,因此 DNS 查询在网关端进行。

    Go
    proxyURL, err := url.Parse("socks5://USERNAME-country-gb:PASSWORD@gw.proxonym.com:1080")
    if err != nil {
    	log.Fatal(err)
    }
    
    client := &http.Client{
    	Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    	Timeout:   60 * time.Second,
    }
    
    resp, err := client.Get("https://api.ipify.org")
    if err != nil {
    	log.Fatal(err)
    }
    defer resp.Body.Close()
    ip, _ := io.ReadAll(resp.Body)
    fmt.Println("Exit IP:", string(ip))
  6. 读取网关状态码并重试

    OnProxyConnectResponse 钩子可以获取每个 CONNECT 请求的状态码。遇到 429、502 和 504 时配合退避策略重试;遇到 402、403 或 407 时则应停止,它们分别指向余额、使用政策或凭据问题。

    Go
    package main
    
    import (
    	"context"
    	"errors"
    	"fmt"
    	"net/http"
    	"net/url"
    	"time"
    )
    
    // gatewayError carries the status the gateway returned for a CONNECT request.
    type gatewayError struct{ status int }
    
    func (e *gatewayError) Error() string { return fmt.Sprintf("gateway returned %d", e.status) }
    
    func newClient(proxyURL *url.URL) *http.Client {
    	return &http.Client{
    		Timeout: 60 * time.Second,
    		Transport: &http.Transport{
    			Proxy: http.ProxyURL(proxyURL),
    			OnProxyConnectResponse: func(_ context.Context, _ *url.URL, _ *http.Request, res *http.Response) error {
    				if res.StatusCode != http.StatusOK {
    					return &gatewayError{status: res.StatusCode}
    				}
    				return nil
    			},
    		},
    	}
    }
    
    func getWithRetry(client *http.Client, target string, tries int) (*http.Response, error) {
    	var err error
    	for attempt := 1; attempt <= tries; attempt++ {
    		var resp *http.Response
    		resp, err = client.Get(target)
    		if err == nil && resp.StatusCode != http.StatusTooManyRequests && resp.StatusCode < 500 {
    			return resp, nil
    		}
    		if err == nil {
    			resp.Body.Close()
    			err = fmt.Errorf("target returned %d", resp.StatusCode)
    		}
    		var gwErr *gatewayError
    		if errors.As(err, &gwErr) && (gwErr.status == 402 || gwErr.status == 403 || gwErr.status == 407) {
    			return nil, err // retrying will not help: fix the balance, target or credentials
    		}
    		time.Sleep(time.Duration(attempt) * time.Second)
    	}
    	return nil, err
    }
    
    func main() {
    	proxyURL, _ := url.Parse("http://USERNAME-country-us:PASSWORD@gw.proxonym.com:8000")
    	resp, err := getWithRetry(newClient(proxyURL), "https://example.com", 3)
    	if err != nil {
    		fmt.Println("request failed:", err)
    		return
    	}
    	defer resp.Body.Close()
    	fmt.Println("status:", resp.StatusCode)
    }

常见问题

Go 无需额外的包即可支持 SOCKS5 代理吗?

可以。net/http 支持 socks5:// 代理 URL(包括用户名和密码),并会把主机名交给代理解析。如需在 HTTP 之外建立原始 TCP 连接,可以使用 golang.org/x/net/proxy 包,它提供的 SOCKS5 拨号器(dialer)接受与 HTTP 端点相同的凭据和用户名参数。

为什么同一个客户端发出的所有请求都显示同一个 IP?

网关按连接选择 IP,而 http.Transport 会在连接保持打开期间复用到同一主机的连接。在用于轮换 IP 的客户端上将 DisableKeepAlives 设为 true,让每个请求都建立新连接;如果需要同时使用多个稳定的 IP,请创建多个使用不同会话 ID 的客户端。

如何查看 HTTPS 请求的网关状态码?

对于 HTTPS 目标,网关状态码属于 CONNECT 请求,通常只会以错误字符串的形式出现。从 Go 1.20 起,http.Transport 上的 OnProxyConnectResponse 钩子可以接收 CONNECT 响应,因此您可以返回一个携带状态码的类型化错误,并据此决定是否重试。

多少个 goroutine 可以同时共用网关?

Proxonym 不限制并发会话数,每个账户的突发请求上限约为每秒 10,000 次。实际上,请求节奏由目标网站决定,因此请用工作池或信号量限制并发数,调整 Transport 的 MaxConnsPerHost,并在收到 429 响应时退避。

准备好接入了吗?立即获取凭据

选择套餐,从控制台复制用户名和密码,然后运行上面的代码。

  • 按量付费
  • 即时开通
  • 支持加密货币
  • 不自动续费