Golang HTTP脚本集成SOCKS5代理及编译报错修复方案

你碰到的ring、localUserPassword、addr等undefined报错，和依赖安装无关，核心是直接复制两份独立代码时，没有处理作用域和标识符导出问题：

• 原SOCKS5代理代码里的环形轮询结构、认证配置、监听参数、更新周期、远程拉取地址等都是局部变量或首字母小写的包内私有标识符，跨作用域/跨包调用时无法访问
• 残留了远程拉取代理列表的ProxyListURL相关逻辑，你现在改用本地文件读取，这部分变量没有定义也没有用到，直接触发编译错误
• 两份代码的配置项没有做统一收敛，零散定义的变量很容易出现遗漏初始化的问题

1. 统一公共配置结构 #

先把两份代码所有配置项收敛到同一个可导出的结构体，不要零散定义全局变量：

package main

import (
	"bufio"
	"context"
	"errors"
	"math/rand"
	"net"
	"net/http"
	"os"
	"strings"
	"sync"
	"time"

	"github.com/armon/go-socks5"
	"golang.org/x/net/proxy"
)

type GlobalConfig struct {
	// 原有高并发HTTP请求配置
	TargetURL     string
	UAListPath    string
	CustomHeaders map[string]string
	RequestMethod string // 支持GET/POST
	Concurrency   int

	// SOCKS5代理配置
	Socks5LocalAddr  string // 本地二级代理监听地址，比如127.0.0.1:1080
	LocalAuthUser    string // 本地代理认证用户名，留空则无认证
	LocalAuthPass    string // 本地代理认证密码
	ProxyListPath    string // 本地代理列表文件路径
	ProxyRefreshSec  int    // 代理列表定时刷新间隔，单位秒
	UpstreamAuthUser string // 上游代理统一认证用户名，若代理自带认证则从文件解析
	UpstreamAuthPass string // 上游代理统一认证密码
}

2. 替换未定义的代理轮询逻辑 #

原代码里未定义的ring本质是轮询上游代理的环形队列，直接实现一个线程安全的轮询结构即可，同时补上本地代理文件读取逻辑，替代原有的ProxyListURL远程拉取逻辑：

// ProxyRing 上游代理轮询器
type ProxyRing struct {
	proxies []string
	idx     int
	mu      sync.Mutex
}

// loadProxyList 从本地文件加载代理，每行格式支持 ip:port 或 user:pass@ip:port
func loadProxyList(filePath string) ([]string, error) {
	f, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	var list []string
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" || strings.HasPrefix(line, "#") { // 跳过空行和注释
			continue
		}
		list = append(list, line)
	}
	return list, scanner.Err()
}

// Next 轮询获取下一个可用上游代理
func (r *ProxyRing) Next() string {
	r.mu.Lock()
	defer r.mu.Unlock()
	if len(r.proxies) == 0 {
		return ""
	}
	p := r.proxies[r.idx]
	r.idx = (r.idx + 1) % len(r.proxies)
	return p
}

// StartAutoRefresh 定时刷新本地代理列表
func (r *ProxyRing) StartAutoRefresh(filePath string, interval time.Duration) {
	ticker := time.NewTicker(interval)
	go func() {
		for range ticker.C {
			newList, err := loadProxyList(filePath)
			if err == nil && len(newList) > 0 {
				r.mu.Lock()
				r.proxies = newList
				r.idx = 0
				r.mu.Unlock()
			}
		}
	}()
}

3. 修复HTTP客户端代理绑定逻辑 #

不要用默认的http.DefaultClient，自定义Transport绑定SOCKS5拨号逻辑，每次发请求前从轮询器取一个上游代理生成客户端即可：

// buildProxyClient 基于指定上游SOCKS5代理生成HTTP客户端
func buildProxyClient(proxyAddr string, authUser, authPass string) (*http.Client, error) {
	var auth *proxy.Auth
	if authUser != "" {
		auth = &proxy.Auth{User: authUser, Password: authPass}
	}
	// 先解析代理地址自带的认证信息
	if strings.Contains(proxyAddr, "@") {
		parts := strings.SplitN(proxyAddr, "@", 2)
		authPart := parts[0]
		proxyAddr = parts[1]
		if strings.Contains(authPart, ":") {
			authInfo := strings.SplitN(authPart, ":", 2)
			auth = &proxy.Auth{User: authInfo[0], Password: authInfo[1]}
		}
	}

	dialer, err := proxy.SOCKS5("tcp", proxyAddr, auth, proxy.Direct)
	if err != nil {
		return nil, err
	}

	transport := &http.Transport{
		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
			return dialer.Dial(network, addr)
		},
		MaxIdleConns:        100,
		IdleConnTimeout:     30 * time.Second,
		MaxIdleConnsPerHost: 10,
	}
	return &http.Client{
		Transport: transport,
		Timeout:   15 * time.Second,
	}, nil
}

4. 修复本地SOCKS5服务的未定义变量 #

原代码里的localUserPassword、addr、port、period全部从GlobalConfig读取，不要用零散的未初始化变量：

// startLocalSocks5 启动本地二级SOCKS5服务
func startLocalSocks5(cfg GlobalConfig, ring *ProxyRing) error {
	// 配置本地认证
	var authMethods []socks5.Authenticator
	if cfg.LocalAuthUser != "" {
		creds := socks5.StaticCredentials{cfg.LocalAuthUser: cfg.LocalAuthPass}
		authMethods = append(authMethods, socks5.UserPassAuthenticator{Credentials: creds})
	} else {
		authMethods = append(authMethods, socks5.NoAuthAuthenticator{})
	}

	// 自定义拨号逻辑，轮询走上游代理
	dialFunc := func(ctx context.Context, network, addr string) (net.Conn, error) {
		upstreamProxy := ring.Next()
		if upstreamProxy == "" {
			return nil, errors.New("no available upstream proxy")
		}
		client, err := buildProxyClient(upstreamProxy, cfg.UpstreamAuthUser, cfg.UpstreamAuthPass)
		if err != nil {
			return nil, err
		}
		transport := client.Transport.(*http.Transport)
		return transport.DialContext(ctx, network, addr)
	}

	server, err := socks5.New(&socks5.Config{
		AuthMethods: authMethods,
		Dial:        dialFunc,
	})
	if err != nil {
		return err
	}

	return server.ListenAndServe("tcp", cfg.Socks5LocalAddr)
}

• 所有跨函数/跨包调用的类型、函数、变量首字母必须大写，Go中首字母小写的标识符仅包内可访问，拆分文件时很容易触发这个问题
• 彻底删除原代理代码中ProxyListURL相关的远程拉取逻辑，这部分变量你已经不需要了，残留的引用直接删掉
• 检查所有用到addr、port、period的位置，确保对应值是从GlobalConfig初始化后传入的，不要直接引用未定义的游离变量
• 原代码中localUserPassword的map全局变量直接删掉，换成上面代码里的socks5库自带的StaticCredentials实现即可
• 代理列表文件初始化时先调用一次loadProxyList，避免轮询器启动时空指针

内容的提问来源于stack exchange，提问作者Robot Qwerty