Golang封装一个request类支持socks和http代理
1. 需要需用国外服务器做代理的时候
2. 需要使用代理服务器做白名单的时候
3. 代码还支持重试机制
封装代码如下
package util
import (
"bytes"
"crypto/tls"
"fmt"
"io"
"mime/multipart"
"net/http"
"net/url"
"strings"
"sync"
"time"
"golang.org/x/net/proxy"
)
const (
ContentTypeFormData = 0
ContentTypeJson = 1
)
type SendRequest struct {
client *http.Client
retryNum int // 重试次数
retryTime int // 重试间隔时间
headers http.Header
boundary string
Lock sync.Mutex
}
func NewSendRequest(contentType int) *SendRequest {
headers := http.Header{}
if contentType == ContentTypeFormData {
headers.Set("Content-Type", "application/x-www-form-urlencoded")
} else if contentType == ContentTypeJson {
headers.Set("Content-Type", "application/json")
}
return &SendRequest{
client: &http.Client{
Timeout: 30 * time.Second,
},
retryTime: 10,
headers: headers,
}
}
func (s *SendRequest) SetBoundary(_boundary string) *SendRequest {
s.boundary = _boundary
return s
}
func (s *SendRequest) SetHeaders(headers http.Header) *SendRequest {
s.headers = headers
return s
}
func (s *SendRequest) UpdateHeaders(headers map[string]string) *SendRequest {
s.Lock.Lock()
defer s.Lock.Unlock()
// 设置请求头
for key, value := range headers {
s.headers.Set(key, value)
}
return s
}
func (s *SendRequest) SetProxy(proxyAddr string) {
// 创建代理 URL
proxyURL, err := url.Parse(proxyAddr)
if err != nil {
fmt.Println("Failed to parse proxy URL:", err)
return
}
var transport *http.Transport
if strings.Contains(proxyAddr, "sock") {
dialer, err := proxy.FromURL(proxyURL, proxy.Direct)
if err != nil {
fmt.Println("Failed to create proxy dialer:", err)
return
}
// 创建自定义的 HTTP 客户端，使用 SOCKS5 代理进行请求
transport = &http.Transport{
Dial: dialer.Dial,
}
// proxy := func(_ *http.Request) (*url.URL, error) {
// return url.Parse(proxyAddr)
// }
// transport = &http.Transport{
// Proxy: proxy,
// }
} else {
// 创建自定义的 Transport
transport = &http.Transport{
Proxy: http.ProxyURL(proxyURL),
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
}
}
s.client.Transport = transport
}
func (s *SendRequest) send(method string, url string, reqBody io.Reader, headers http.Header) ([]byte, *http.Response, error) {
req, err := http.NewRequest(method, url, reqBody)
if err != nil {
return nil, nil, err
}
// 设置请求头
if len(headers) > 0 {
req.Header = headers
} else {
req.Header = s.headers
}
resp, err := s.client.Do(req)
if err != nil {
return nil, nil, err
}
defer resp.Body.Close()
// s.Lock.Lock()
body, err := io.ReadAll(resp.Body)
// s.Lock.Unlock()
if err != nil {
return nil, nil, err
}
if resp.StatusCode != http.StatusOK {
// return nil, nil, errors.New(fmt.Sprintf("状态码：%d，内容：%s", resp.StatusCode, string(body)))
return nil, nil, fmt.Errorf("状态码：%d", resp.StatusCode)
}
return body, resp, nil
}
func (s *SendRequest) Post(url string, param url.Values) ([]byte, *http.Response, error) {
reqBody := strings.NewReader(param.Encode())
// 设置请求参数
if s.boundary != "" {
// 创建请求体
buf := &bytes.Buffer{}
writer := multipart.NewWriter(buf)
// 设置分割符号（boundary）
writer.SetBoundary(s.boundary)
// 添加表单字段到请求体
for key, value := range param {
for _, v := range value {
_ = writer.WriteField(key, v)
}
}
// 关闭 multipart.Writer，以写入结尾标识符
_ = writer.Close()
reqBody = strings.NewReader(buf.String())
}
return s.send("POST", url, reqBody, nil)
}
func (s *SendRequest) PostJSON(url string, data []byte) ([]byte, *http.Response, error) {
var reqBody *bytes.Reader
if data != nil {
reqBody = bytes.NewReader(data)
}
return s.send("POST", url, reqBody, nil)
}
func (s *SendRequest) RepeatPost(url string, param url.Values) ([]byte, *http.Response, error) {
// fmt.Printf("[%s][%d]请求地址：%s\n", uuid, num, url)
// fmt.Printf("[%s][%d]本次发送：%v\n", uuid, num, param)
result, resp, err := s.Post(url, param)
if err != nil && s.retryNum < 5 {
time.Sleep(time.Second * time.Duration(s.retryTime))
// fmt.Printf("[%s][%d]请求返回错误：%v\n", uuid, num, err)
s.retryNum++
s.retryNum = s.retryNum * 2
// 进行重发
return s.RepeatPost(url, param)
}
return result, resp, err
}
func (s *SendRequest) Get(url string, headers http.Header) ([]byte, *http.Response, error) {
return s.send("GET", url, nil, headers)
}
// func main() {
// req := NewSendRequest()
// // 测试 POST 请求
// postURL := "http://example.com/api"
// postParam := url.Values{
// "key1": []string{"value1"},
// "key2": []string{"value2"},
// }
// postHeaders := map[string]string{
// "Content-Type": "application/x-www-form-urlencoded",
// }
// postResult, err := req.Post(postURL, postParam, postHeaders)
// if err != nil {
// fmt.Println("POST 请求错误:", err)
// } else {
// fmt.Println("POST 请求结果:", postResult)
// }
// // 测试重复发送 POST 请求
// repeatUUID := "12345"
// repeatURL := "http://example.com/api"
// repeatParam := url.Values{
// "key1": []string{"value1"},
// "key2": []string{"value2"},
// }
// repeatTimeout := 0 * time.Second
// repeatNum := 1
// repeatHeaders := map[string]string{
// "Content-Type": "application/x-www-form-urlencoded",
// }
// req.RepeatPost(repeatUUID, repeatURL, repeatParam, repeatTimeout, repeatNum, repeatHeaders)
// // 测试 GET 请求
// getURL := "http://example.com/api"
// getHeaders := map[string]string{
// "Content-Type": "application/x-www-form-urlencoded",
// }
// getResult, err := req.Get(getURL, getHeaders)
// if err != nil {
// fmt.Println("GET 请求错误:", err)
// } else {
// fmt.Println("GET 请求结果:", getResult)
// }
// }
使用代理请求
package main
import (
"log"
"xxx/utils"
)
func main() {
// 这个网站有很多代理ip，但是大部分都用不了会超时或者连接拒绝
// https://geonode.com/free-proxy-list
// 付费的三方https://ip.huashengdaili.com/
sendRequest := utils.NewSendRequest(nil, "")
sendRequest.SetProxy("socks4://169.239.49.118:5678")
// https://api.ip.sb/ip
// https://myip.top
body, _, err := sendRequest.Get("https://myip.top", nil)
if err != nil {
log.Fatal(err)
}
log.Println(string(body))
}
当然可以自己搭建一个socks5和http的代理服务器
自己搭建代码如下：
package main
import (
"io"
"log"
"net"
"net/http"
"os"
"github.com/armon/go-socks5"
)
func handleRequest(w http.ResponseWriter, r *http.Request) {
// 建立与后端服务器的连接
destConn, err := net.Dial("tcp", r.Host)
if err != nil {
log.Println("Failed to connect to destination:", err)
http.Error(w, "Failed to connect to destination", http.StatusInternalServerError)
return
}
defer destConn.Close()
// 将客户端的请求发送到后端服务器
err = r.Write(destConn)
if err != nil {
log.Println("Failed to send request to destination:", err)
http.Error(w, "Failed to send request to destination", http.StatusInternalServerError)
return
}
// 将后端服务器的响应返回给客户端
_, err = io.Copy(w, destConn)
if err != nil {
log.Println("Failed to send response to client:", err)
http.Error(w, "Failed to send response to client", http.StatusInternalServerError)
return
}
}
func main() {
// 创建代理服务器处理程序
proxyHandler := http.HandlerFunc(handleRequest)
// 启动HTTPS代理服务器
go func() {
log.Println("proxy 8080")
err := http.ListenAndServeTLS(":8080", "./pem/cert.pem", "./pem/key.pem", proxyHandler)
if err != nil {
log.Fatal("Failed to start proxy server:", err)
}
}()
// 启动SOCKS5代理服务器
socksConf := &socks5.Config{}
socksServer, err := socks5.New(socksConf)
if err != nil {
log.Fatal("Failed to create SOCKS5 server:", err)
}
socksListener, err := net.Listen("tcp", ":1080")
if err != nil {
log.Fatal("Failed to start SOCKS5 server:", err)
}
log.Println("SOCKS5 proxy 1080")
err = http.Serve(socksListener, socksServer)
if err != nil {
log.Fatal("Failed to start SOCKS5 server:", err)
}
}
证书生成
1. openssl生成参考：https://cloud.tencent.com/developer/article/1548350
2. 在线生成：https://www.lddgo.net/encrypt/ssl
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
