网络代理【4】ReverseProxy源码分析及使用

一时失言乱红尘 2023-03-01 12:25 10阅读 0赞

上一篇实现代理服务器不具备的功能有:

*  错误回调及错误日志处理
 *  更改代理返回内容
 *  负载均衡
 *  url重写
 *  限流、熔断、降级
 *  数据统计
 *  权限认证  
    —[《网络代理【3】Golang实现简单的反向代理》][3_Golang]

--------------------

目录:
    一、ReverseProxy快速入门:
    二、ReverseProxy功能剖析及实现:
    	- url重新功能
    	- 更改内容支持、错误回调、连接池
    	- 支持Websocket代理
    	- 支持HTTPS代理
    三、HTTP特殊Header头和特殊状态码:
    	- header头
    	- 特殊状态码
    	- 代理请求后端需要注意的点

**一、ReverseProxy快速入门**  
![在这里插入图片描述][20210411121359771.png_pic_center]  
可以看到ReverseProxy已经实现了ServeHTTP方法。意为着它能作为http.Server.Handler参数传入。被http.Server进行调用。  
详情请看[《网络编程【6】Golang实现HTTP 服务端和客户端》][6_Golang_HTTP]  
那么就用ReverseProxy实现一个HTTP代理

var realAddr, proxyAddr = "http://172.*.*.248:8081", "172.*.*.249:3000"
    func main() { 
    	backend, _ := url.Parse(realAddr)
    	handler := httputil.NewSingleHostReverseProxy(backend)
    	log.Fatal(http.ListenAndServe(proxyAddr, handler))
    }

`或者`

var realAddr, proxyAddr = "http://172.*.*.248:8081", "172.*.*.249:3000"
    func main() { 
    	backend, _ := url.Parse(realAddr)
    	server := http.Server{ 
    		Addr:         proxyAddr,
    		WriteTimeout: time.Second * 3,
    		Handler:      httputil.NewSingleHostReverseProxy(backend),
    	}
    	log.Fatal(server.ListenAndServe())
    }

**二、ReverseProxy功能剖析及实现**  
**2.1 url重新功能**  
当我们真是服务器地址有路径时，会发生什么情况？

realAddr := "http://172.*.*.248:8081/mypath"

访问代理 http://172.?.?.249:3000/abc，实际向真实服务器请求URL为http://172.?.?.248:8081/mypath/abc  
所以ReverseProxy已经实现了重写功能，会把用户输入路径path追加到端点路径之后  
分析一下源码,打开httputil.NewSingleHostReverseProxy。

*  singleJoiningSlash是拼接路径的
 *  req.URL.Path正是把后端路径追加用户输入路径

package httputil
    func singleJoiningSlash(a, b string) string { 
    	aslash := strings.HasSuffix(a, "/")
    	bslash := strings.HasPrefix(b, "/")
    	switch { 
    	case aslash && bslash:
    		return a + b[1:]
    	case !aslash && !bslash:
    		return a + "/" + b
    	}
    	return a + b
    }
    
    func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy { 
    	targetQuery := target.RawQuery
    	director := func(req *http.Request) { 
    		...
    		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
    		...
    	}
    	return &ReverseProxy{ Director: director}
    }

**2.2 更改内容支持、错误回调、连接池**  
我们看一下ReverseProxy结构体参数源码

package httputil
    type ReverseProxy struct { 
    	// 控制器，可以对request进行修改
    	Director func(*http.Request)
    
    	// 连接池，如果为空，会自动生成默认的transport对象
    	Transport http.RoundTripper
    
    	// 刷新数据频率，数据就是请求资源返回的response给客户端的
    	FlushInterval time.Duration
    
    	// 记录代理请求出错的日志
    	ErrorLog *log.Logger
    
    	// 缓冲池，接收response的body数据的
    	BufferPool BufferPool
    
    	// 在请求完真实服务器后对返回数据response进行修改
    	// 如果真实服务器挂了，会触发ErrorHandler函数, 就不会触发当前的函数体
    	// 如果这个函数出错也会触发ErrorHandler
    	// 用户不传就会使用其默认实现
    	ModifyResponse func(*http.Response) error
    
    	// 用于处理到达后端的错误或ModifyResponse中的错误。
    	// 用户不实现,则是记录提供的错误并返回502响应。
    	ErrorHandler func(http.ResponseWriter, *http.Request, error)
    }

① 开启真实后端服务器，代码在[这篇文章][3_Golang]的第一节  
② 根据以上分析，仅需实现Director 和ModifyResponse 函数体即可，丢弃NewSingleHostReverseProxy

var realAddr, proxyAddr = "http://172.*.*.248:8081", "172.*.*.249:3000"
    
    func singleJoiningSlash(a, b string) string { 
    	...跟上面第二节1.1的singleJoiningSlash一样
    }
    
    type Proxy struct { 
    	URL *url.URL
    }
    
    func NewProxy(addr string) (*Proxy, error) { 
    	purl, err := url.Parse(addr)
    	return &Proxy{ 
    		URL: purl,
    	}, err
    }
    
    func (p *Proxy) NewMyReverseProxy() *httputil.ReverseProxy { 
    	return &httputil.ReverseProxy{ 
    		Director:       p.Director,
    		ModifyResponse: p.ModifyResponse,
    	}
    }
    
    func (p *Proxy) Director(req *http.Request) { 
    	query := p.URL.RawQuery
    	req.URL.Scheme = p.URL.Scheme
    	req.URL.Host = p.URL.Host
    	req.URL.Path = singleJoiningSlash(p.URL.Path, req.URL.Path)
    	if query == "" || req.URL.RawQuery == "" { 
    		req.URL.RawQuery = query + req.URL.RawQuery
    	} else { 
    		req.URL.RawQuery = query + "&" + req.URL.RawQuery
    	}
    	if _, ok := req.Header["User-Agent"]; !ok { 
    		req.Header.Set("User-Agent", "")
    	}
    }
    
    func (p *Proxy) ModifyResponse(res *http.Response) error { 
    	// 如果资源服务器返回500, 就把内容进行更改
    	// 后端已实现只用请求/error资源就会触发500
    	if res.StatusCode == 500 { 
    		// 1.先把内容全部读出来
    		data, _ := ioutil.ReadAll(res.Body)
    		// 2.在追加内容
    		data = []byte("BlackLivesMatter " + string(data))
    		// 3.再次写进去
    		res.ContentLength = int64(len(data))
    		res.Header.Set("Content-Length", fmt.Sprint(len(data)))
    		res.Body = ioutil.NopCloser(bytes.NewBuffer(data))
    	}
    	return nil
    }
    
    func main() { 
    	proxy, err := NewProxy(realAddr)
    	if err != nil { 
    		log.Fatal(err)
    	}
    	server := &http.Server{ 
    		Addr:         proxyAddr,
    		WriteTimeout: time.Second * 3,
    		Handler:      proxy.NewMyReverseProxy(),
    	}
    	log.Fatal(server.ListenAndServe())
    }

![在这里插入图片描述][20210411165144740.png_pic_center]

**2.3 支持Websocket服务**  
[《网络代理【7】Golang使用ReverseProxy实现Websocket代理》][7_Golang_ReverseProxy_Websocket]  
**2.4 支持https代理**  
[《网络代理【8】Golang使用ReverseProxy实现HTTPS代理》][8_Golang_ReverseProxy_HTTPS]

三、HTTP特殊Header头和特殊状态码  
**3.1 特殊Header头**

*  Connection: 当前事务完成后，对当前网络的操作keep-alive(不关闭)、close(关闭)、Upgrade(协议升级)
 *  TE：是request\_header，表示希望使用的传输编码类型。例如TE:tralers,default=0.5，表示期望在采用分块传输编码响应中接收挂载字段，zlib编码，0.5优先级排序
 *  Trailer：是response\_header,允许发送方在消息后面添加额外元信息。例如Traler: Expires，表示Expries将出现在分块信息的结尾。
 *  X-Forwarded-For: 转发过程中的主机链路
 *  X-Real-IP: 实际发起者的ip

**3.2 特殊的状态码**

*  100 表示目前一切正常、客户端可以继续请求。客户端要post的数据大于1024字节的时候，客户端不会直接发起post，而是分为两步：首先发送一个请求，包含Expect:100-continue，询问服务端是否愿意接受数据。其次服务收到该请求后，返回100, 客户端才发起post
 *  101 表示服务端发送给客户端升级协议的请求  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center]

**3.3 代理请求后端需要注意的点**

*  去除标准的逐段传输头: 逐段传输头都需要在Connection头中列出
 *  第一代理必须处理一些操作(比如协议升级)，而不用转发它们
 *  需要去除的逐段传输头：Keep-Alive、Transfer-Encoding、TE、Connection、Trailer、Upgrade、Proxy-Authorization、Proxy-Authenticate

[3_Golang]: https://blog.csdn.net/qq_38900565/article/details/104690103
[20210411121359771.png_pic_center]: /images/20230208/c1ad946ec46746c798e97d86b45d1913.png
[6_Golang_HTTP]: https://blog.csdn.net/qq_38900565/article/details/115578604
[20210411165144740.png_pic_center]: /images/20230208/18e17da5608d46edb5f92fb6d64ff7ed.png
[7_Golang_ReverseProxy_Websocket]: https://blog.csdn.net/qq_38900565/article/details/1046901
[8_Golang_ReverseProxy_HTTPS]: https://blog.csdn.net/qq_38900565/article/details/1046902
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center]: /images/20230208/0fe906bd0a6a4b03bb795cca950fd9cc.png