http代理简单实现

  1. 用户请求代理服务器 =》 上游 tcp连接=》回调方法=》拷贝请求数据 =》 请求下游服务器 => 获得结果回写上游数据

golang连接池原理 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package main

import (
	"bufio"
	"fmt"
	"log"
	"net/http"
	"net/url"
)

var (
	baidu_addr = "http://javatribe.bigliang.top:8080"
	proxy_addr = baidu_addr
	// proxy_addr = "http://127.0.0.1:2003"
	port = "8080"
)

func handler(w http.ResponseWriter, r *http.Request) {
	//step 1 解析代理地址，并更改请求体的协议和主机
	proxy, err := url.Parse(proxy_addr)
	r.URL.Scheme = proxy.Scheme
	r.URL.Host = proxy.Host
	fmt.Println("request on ", proxy.Scheme, proxy.Host)

	//step 2 请求下游
	transport := http.DefaultTransport
	resp, err := transport.RoundTrip(r)
	if err != nil {
		log.Print(err)
		return
	}

	//step 3 把下游请求内容返回给上游
	for k, vv := range resp.Header {
		for _, v := range vv {
			w.Header().Add(k, v)
		}
	}
	defer resp.Body.Close()
	bufio.NewReader(resp.Body).WriteTo(w)
}

func main() {
	http.HandleFunc("/", handler)
	//访问 port 端口 就会改为 访问 百度
	log.Println("Start serving on port " + port)
	err := http.ListenAndServe(":"+port, nil)
	if err != nil {
		log.Fatal(err)
	}
}

以上代码补充

  • 错误回调以及错误日志处理
  • 更改代理返回内容
  • 负载均衡
  • url重写

用 golang 官方提供的 reverseProxy 实现 http代理

  • ReverseProxy 功能点
  • ReverseProxy 示例

官方的 reverseProxy 支持如下功能

  • 支持更改内容
  • 用了连接池优化
  • 支持自定义负载均衡
  • 支持url重写
  • 支持 websocket
  • 支持https代理

参考文章

扩展 ReverseProxy 功能

  • 4种负载均衡策略 以及接口封装
  • 扩展 中间件支持： 限流、熔断实现、权限、数据统计
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

import (
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
)

var (
	baidu_addr = "http://javatribe.bigliang.top:8080"
	proxy_addr = baidu_addr
	// proxy_addr = "http://127.0.0.1:2003"
	local = "127.0.0.1:8080"
)

func main() {
	// http.HandleFunc("/", handler)
	target, err := url.Parse(baidu_addr)
	if err != nil {
		panic(err)
	}
	//访问 port 端口 就会改为 访问 百度
	log.Println("Start serving on port " + local)
	proxy := httputil.NewSingleHostReverseProxy(target)

	http.ListenAndServe(local, proxy)
	if err != nil {
		log.Fatal(err)
	}
}

httputil部分源码解析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy {
	targetQuery := target.RawQuery
    //分发器=》 将请求解析 分发到 对应的 地址
	director := func(req *http.Request) {
		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host
		req.URL.Path, req.URL.RawPath = joinURLPath(target, req.URL)
		if targetQuery == "" || req.URL.RawQuery == "" {
			req.URL.RawQuery = targetQuery + req.URL.RawQuery
		} else {
			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
		}
        //设置请求头
		if _, ok := req.Header["User-Agent"]; !ok {
			// explicitly disable User-Agent so it's not set to default value
			req.Header.Set("User-Agent", "")
		}
	}
	return &ReverseProxy{Director: director}
}