Go网络请求中配置代理

如何配置代理

不配置代理，本地请求google等会超时

go 复制代码

package main

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

func main() {
	// 创建一个自定义的 Transport 实例
	//transport := &http.Transport{
	//	Proxy: func(req *http.Request) (*url.URL, error) {
	//		//	return url.Parse("http://127.0.0.1:1081")
	//		return url.Parse("socks5://127.0.0.1:1080")
	//	},
	//}

	// 创建一个自定义的 Client 实例
	client := &http.Client{
		//Transport: transport, // 设置代理
		Timeout: time.Second * 3, // 设置超时
	}

	urlStr := "https://www.google.com/"
	// 发送 GET 请求
	resp, err := client.Get(urlStr)
	if err != nil {
		// 处理错误
		fmt.Println("发生了错误:err", err)
		return
	}
	defer resp.Body.Close()

	// 处理响应

	fmt.Println(resp.StatusCode)
}

输出: 发生了错误:err Get "https://www.google.com/": context deadline exceeded (Client.Timeout exceeded while awaiting headers)

取消注释，则会输出 200

go http Client的Transport字段有什么作用

在 Go 的 http 包中，Client 类型代表了 HTTP 客户端。在 Client 中有一个名为 Transport 的字段，它是一个 http.RoundTripper 接口类型的值，用于处理 HTTP 请求和响应的传输细节。

通过设置 Transport 字段，可以对 HTTP 请求进行一些自定义设置，比如设置代理、设置超时、设置 TLS 客户端证书等。Transport 字段提供了一些默认实现，也可以通过实现 http.RoundTripper 接口来自定义实现。

例如，可以通过自定义 Transport 来设置 HTTP 代理：

go 复制代码

transport := &http.Transport{
    Proxy: func(req *http.Request) (*url.URL, error) {
        return url.Parse("http://127.0.0.1:8888")
    },
}
client := &http.Client{
    Transport: transport,
}

在上面的代码中，通过自定义 Transport 并设置代理来实现将所有 HTTP 请求通过本地的代理服务器进行转发。这样就可以在代理服务器上进行一些中间人攻击的操作，如抓包、篡改请求等。

设置超时不是这个字段吧

确实... 在 Go 的 http.Client 中，超时是通过 Timeout 字段来设置的，而 Transport 字段用于控制 HTTP 客户端的网络传输设置，例如代理、TLS 配置、连接池等。超时时间是通过 Timeout 字段指定的，而不是 Transport 字段。

我在用go写一段请求很多个url然后返回响应内容的程序，通过设置http Client的Transport设置了代理，但发现大量的EOF，这是什么原因？

在使用 HTTP 客户端请求多个 URL 时，如果设置了代理，可能会导致连接出现大量的 EOF 错误。这通常是由于代理服务器在连接到远程服务器时关闭了连接，而客户端仍在尝试使用已关闭的连接进行通信，从而导致错误。

一种可能的解决方案是，针对每个请求创建一个新的 HTTP 客户端，并在使用完毕后立即关闭它。这样可以确保每个请求都使用一个新的连接，避免出现连接复用的问题。示例代码如下：

go 复制代码

func fetchURL(url string) (string, error) {
    // 创建一个自定义的 Transport 实例
    transport := &http.Transport{
        Proxy: func(req *http.Request) (*url.URL, error) {
            return url.Parse("http://127.0.0.1:1080") // 设置代理
        },
    }

    // 创建一个自定义的 Client 实例
    client := &http.Client{
        Transport: transport, // 设置 Transport
        Timeout:   time.Second * 3, // 设置超时
    }

    // 发送 GET 请求
    resp, err := client.Get(url)
    if err != nil {
        // 处理错误
        return "", err
    }
    defer resp.Body.Close()

    // 读取响应内容
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        // 处理错误
        return "", err
    }

    // 返回响应内容
    return string(body), nil
}

func main() {
    urls := []string{
        "http://example.com",
        "http://example.org",
        "http://example.net",
    }

    // 遍历 URL 列表，并发送请求
    for _, url := range urls {
        resp, err := fetchURL(url)
        if err != nil {
            fmt.Printf("fetch %s error: %s\n", url, err)
        } else {
            fmt.Printf("fetch %s success: %s\n", url, resp)
        }
    }
}

此外，还可以尝试对 Transport 的 MaxIdleConnsPerHost 和 MaxIdleConns 进行调整，以确保连接复用时不会出现连接超时或连接关闭的问题。

Transport 的 MaxIdleConnsPerHost 和 MaxIdleConns 是什么意思

Transport的MaxIdleConnsPerHost和MaxIdleConns字段都是用来控制http client连接池的大小和行为的。

MaxIdleConnsPerHost：指定连接池中每个主机允许的最大空闲连接数。默认值是2。
MaxIdleConns：指定整个连接池允许的最大空闲连接数。默认值是无限制。

当http client创建一个连接时，它将尝试重用现有的空闲连接。如果连接池中没有空闲连接，则http client将创建一个新的连接。如果连接池中的空闲连接已达到MaxIdleConns或MaxIdleConnsPerHost，则http client将关闭连接。

因此，如果将MaxIdleConns和MaxIdleConnsPerHost设置得太小，那么http client将会频繁地关闭和创建连接，这会导致一些EOF错误。可以适当地增加这些字段的值，以减少这些错误的发生。

如何设置？

可以通过在创建 Transport 实例时进行设置，例如：

go 复制代码

transport := &http.Transport{
    MaxIdleConnsPerHost: 10,  // 每个主机最大空闲连接数
    MaxIdleConns:        100, // 最大空闲连接数
}

其中，MaxIdleConnsPerHost 表示每个主机最大的空闲连接数，MaxIdleConns 表示所有主机的最大空闲连接数。您可以根据实际情况进行调整。需要注意的是，如果 MaxIdleConnsPerHost 设置的太小，可能会导致无法复用连接，从而增加了连接的建立和关闭成本；如果设置的太大，可能会占用过多的系统资源。