我要评论1.源码结构体
type reverseproxy struct {
// rewrite 必须是一个函数，用于将请求修改为要使用 transport 发送的新请求。然后，其响应将原封不动地复制回原始客户端。返回后，rewrite 不得访问提供的 proxyrequest 或其内容。
// 在调用 rewrite 之前，将从出站请求中删除 forwarded、x-forwarded、x-forwarded-host 和 x-forwarded-proto 标头。另请参阅 proxyrequest.setxforwarded 方法。
// 在调用 rewrite 之前，将从出站请求中删除不可解析的查询参数。rewrite 函数可以将入站 url 的 rawquery 复制到出站 url 以保留原始参数字符串。请注意，如果代理对查询参数的解释与下游服务器的解释不匹配，这可能会导致安全问题。
// 最多可以设置 rewrite 或 director 中的一个。
rewrite func(*proxyrequest)
// director 是一种将请求修改为要使用 transport 发送的新请求的功能。然后，其响应将原封不动地复制回原始客户端。director 在返回后不得访问提供的请求。
//默认情况下，x-forwarded-for 标头设置为客户端 ip 地址的值。如果 x-forwarded-for 标头已存在，则客户端 ip 将附加到现有值。作为特殊情况，如果标头存在于 request.header 映射中，但具有 nil 值（例如由 director func 设置时），则不会修改 x-forwarded-for 标头。
// 为防止 ip 欺骗，请务必删除来自客户端或不受信任的代理的任何预先存在的 x-forwarded-for 标头。
// 在 director 返回后，将从请求中删除逐跳标头，这可以删除 director 添加的标头。请改用 rewrite 函数来确保保留对请求的修改。
// 如果在 director 返回后设置 request.form，则会从出站请求中删除不可解析的查询参数。
// 最多可以设置 rewrite 或 director 中的一个。
director func(*http.request)
// 用于执行代理请求的传输。如果为 nil，则使用为 http.defaulttransport
transport http.roundtripper
// flushinterval 指定在复制响应正文时要刷新到客户端的刷新间隔。如果为零，则不执行定期刷新。负值表示在每次写入 client 端后立即刷新。当 reverseproxy 将响应识别为流式响应或其 contentlength 为 -1 时，将忽略 flushinterval;对于此类响应，写入会立即刷新到客户端。
flushinterval time.duration
// errorlog 为尝试代理请求时发生的错误指定可选记录器。如果为 nil，则通过 log 包的标准 logger 完成日志记录。
errorlog *log.logger
// bufferpool 可以选择指定一个缓冲池，以获取 io 使用的字节切片。copybuffer 在复制 http 响应正文时。
bufferpool bufferpool
// modifyresponse 是一个可选函数，用于修改来自后端的 response。如果后端返回带有任何 http 状态代码的响应，则调用它。如果无法访问后端，则调用可选的 errorhandler，而不调用 modifyresponse。如果 modifyresponse 返回错误，则调用 errorhandler 及其错误值。如果 errorhandler 为 nil，则使用其默认实现。
modifyresponse func(*http.response) error
// errorhandler 是一个可选函数，用于处理到达后端的错误或来自 modifyresponse 的错误。如果为 nil，则默认记录提供的错误并返回 502 status bad gateway 响应。
errorhandler func(http.responsewriter, *http.request, error)
}2.官方单机示例
newsinglehostreverseproxy是官方给的示例，代理单机服务，如果想实现负载均衡，需自己实现。
源码：
3.使用示例
package main
import (
"log"
"net"
"net/http"
"net/http/httputil"
"net/url"
"os"
"sync"
"time"
)
// 从go 1.18版本开始，httputil.reverseproxy 的 bufferpool 字段期望的是一个实现了 bufferpool 接口的对象，该接口要求有一个返回 []byte 的 get 方法和一个接受 []byte 的 put 方法。
// 定义一个实现了 bufferpool 接口的结构体
// 定义一个实现了 bufferpool 接口的结构体
type bytebufferpool struct {
sync.pool
}
// 实现 bufferpool 接口的 get 方法
func (b *bytebufferpool) get() []byte {
v := b.pool.get()
if v == nil {
return make([]byte, 1024*1024) // 分配 1mb 的缓冲区
}
return v.([]byte)
}
// 实现 bufferpool 接口的 put 方法
func (b *bytebufferpool) put(bts []byte) {
b.pool.put(bts)
}
// 定义一个实现了 errorhandler 接口的函数
func customerrorhandler(w http.responsewriter, r *http.request, err error) {
// 记录错误
log.printf("error occurred: %v", err)
// 返回自定义的状态码和错误消息
w.writeheader(http.statusinternalservererror)
w.write([]byte("an internal error occurred."))
}
func main() {
// 目标服务器的 url
targeturl := "http://localhost:8081"
// 解析目标 url
target, err := url.parse(targeturl)
if err != nil {
log.fatalf("failed to parse target url: %v", err)
}
// 创建反向代理
proxy := httputil.newsinglehostreverseproxy(target)
// 设置 flushinterval
// flushinterval 是一个 time.duration 类型的字段，它指定了代理服务器将缓冲的数据写入客户端的间隔时间。这对于实现实时应用（如实时聊天、日志流等）非常重要，因为它可以减少延迟，让客户端更快地接收到数据。
proxy.flushinterval = 100 * time.millisecond
// 设置反向代理的 transport
proxy.transport = &http.transport{
dialcontext: (&net.dialer{
timeout: 30 * time.second, // 建立连接的最大等待时间
keepalive: 30 * time.second, // 保持连接活跃的时间间隔
dualstack: true, // 尝试同时使用 ipv4 和 ipv6 地址
}).dialcontext,
maxidleconns: 100, // 最大空闲连接数
idleconntimeout: 90 * time.second, // 空闲连接超时时间
tlshandshaketimeout: 10 * time.second, // tls握手超时时间
expectcontinuetimeout: 1 * time.second, // expect: 100-continue 超时时间
}
// 创建自定义的日志器
proxy.errorlog = log.new(os.stderr, "error: ", log.lstdflags)
// 设置反向代理的 bufferpool 缓冲池
proxy.bufferpool = &bytebufferpool{
pool: sync.pool{
new: func() interface{} {
return make([]byte, 1024*1024) // 分配 1mb 的缓冲区
},
},
}
// 设置反向代理的 modifyresponse
proxy.modifyresponse = func(res *http.response) error {
// 修改响应头
res.header.set("x-modified-by", "reverseproxy")
// 修改状态码（示例）
res.statuscode = 200
// 返回 nil 表示继续处理
return nil
}
// 设置反向代理的 errorhandler
proxy.errorhandler = customerrorhandler
// 创建 http 服务器
http.handlefunc("/", func(w http.responsewriter, r *http.request) {
// 调用反向代理
proxy.servehttp(w, r)
})
// 启动 http 服务器
log.println("starting server on :8080")
log.fatal(http.listenandserve(":8080", nil))
}4.简单的http服务（用于测试）
package main
import (
"fmt"
"log"
"net/http"
)
func helloworldhandler(w http.responsewriter, r *http.request) {
fmt.fprintf(w, "hello, world!")
}
func main() {
http.handlefunc("/", helloworldhandler)
log.println("starting server on :8081")
log.fatal(http.listenandserve(":8081", nil))
}到此这篇关于golang使用reverseproxy实现反向代理的文章就介绍到这了,更多相关golang reverseproxy反向代理内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论