API网关从零实现-Golang篇

func main() {
	target, _ := url.Parse("http://127.0.0.1:2003")
	reverseProxy := httputil.NewSingleHostReverseProxy(target)
	http.ListenAndServe(":2002", reverseProxy)
}

// ReverseProxy是一个HTTP Handler，它接受传入的请求并将其发送到另一台服务器，将响应代理回客户。
type ReverseProxy struct {
	// 必须，用于将请求转化为使用Transport传输新的请求并发送。然后复制它的响应回到未修改的原始客户端。不能访问返回后的内容。
	Director func(*http.Request)

	// 可选，用于执行代理请求的传输。默认http.DefaultTransport
	Transport http.RoundTripper

	// 可选，指定刷新间隔
	FlushInterval time.Duration

	// 可选，自定义日志收集器
	ErrorLog *log.Logger

	// 可选，指定一个缓冲池来获取字节切片供io.CopyBuffer使用时复制 HTTP 响应正文
	BufferPool BufferPool

	// 可选，用于修改来自后端的响应
	ModifyResponse func(*http.Response) error

	// 可选，用于处理到达后端的错误或来自ModifyResponse的错误
	ErrorHandler func(http.ResponseWriter, *http.Request, error)
}

// 实现了ServeHTTP
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {}

// 新建单主机反向代理
func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy {
	return &ReverseProxy{Director: director}
}

// Proxy 多后端（target）代理
type Proxy struct {
}

// NewHttpReverseProxy 创建代理
func (p *Proxy) NewHttpReverseProxy(target *url.URL) *httputil.ReverseProxy {
	rp := httputil.NewSingleHostReverseProxy(target)
	return rp
}

// ServeHTTP 实现接口：ServeHTTP(w http.ResponseWriter, r *http.Request)
func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	var target *url.URL
	if r.URL.Path == "/test1" {
		target, _ = url.Parse("http://127.0.0.1:2003")
	} else if r.URL.Path == "/test2" {
		target, _ = url.Parse("http://127.0.0.1:2004")
	} else {
		target, _ = url.Parse("http://127.0.0.1:2005")
	}
	proxy := p.NewHttpReverseProxy(target)
	proxy.ServeHTTP(w, r)
}

func main() {
	addr := ":2002"
	p := &Proxy{}
	log.Println("Starting HttpServer at " + addr)
	err := http.ListenAndServe(addr, p)
	if err != nil {
		log.Fatalln("ListenAndServe: ", err)
	}
}

// ServeHTTP 实现接口：ServeHTTP(w http.ResponseWriter, r *http.Request)
func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// ps：实际上下面的第一步和第二步应该放在启动过程中就初始化好，这里为了大家理解放到这
	// 第一步：获取服务路由配置
	services := p.getServices(r)

	// 第二步：生成前缀树
	tree := p.getRouteTree(services)

	// 第三步：从前缀树中匹配出当前请求所匹配的目标服务
	route, _ := p.findRouteWithRouteTree(r, tree)
	if route == nil {
		proxy1 := http.NewServeMux()
		proxy1.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(404)
			fmt.Fprintf(w, "404 not found")
		}))
		proxy1.ServeHTTP(w, r)
		return
	}

	// 第四步：反向代理
	target, _ := url.Parse(route.Service.Conf.Upstream)
	proxy := httputil.NewSingleHostReverseProxy(target)
	proxy.ServeHTTP(w, r)
}

1、随机
每次请求都是完全随机选取一个节点
2、一致hash
相同来源条件下的请求都会选取到同一个节点
3、轮询
依次轮流选取节点
4、加权轮询
给服务器分配权重，依照权重选取节点

type WeightedNode struct {
	addr            string // 服务器addr
	weight          int    // 配置的权重，即在配置文件或初始化时约定好的每个节点的权重
	curWeight       int    // 有效权重，初始值为weight
	effectiveWeight int    // 节点当前权重
}

// 注册、匹配插件
func (p *Proxy) SetPlugins() {
	p.Plugins = append(p.Plugins, logp.NewPlugin())
	p.Plugins = append(p.Plugins, cors.NewPlugin())
	// 根据权重排序
	p.Plugins = p.orderPlugins(p.Plugins)
}

//运行路由阶段插件
func (p *Proxy) RouteFlow(ctx *context.GatewayContext) {
	select {
	case <-ctx.Context.Done():
	default:
	}
	for _, pl := range p.Plugins {
		if err := pl.Route(ctx); err != nil {
			fmt.Println(err)
		}
	}
}

//运行proxy阶段插件
func (p *Proxy) ProxyFlow(ctx *context.GatewayContext) {
	fmt.Println("from ctx key1", ctx.Get("key1"))
	for _, pl := range p.Plugins {
		if err := pl.Proxy(ctx); err != nil {
			fmt.Println(err)
		}
	}
}

//实现接口：ServeHTTP(w http.ResponseWriter, r *http.Request)
func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	ctx := context.NewContext(w, r)

	//在这个时候运行路由阶段中间件
	p.RouteFlow(ctx)

	var target *url.URL
	//获取目标服务
	target = p.GetRemotes(r)

	//创建反向代理
	proxy := p.NewHttpReverseProxy(target)

	//服务处理
	proxy.ServeHTTP(w, r)

	//在这个时候运行Proxy阶段中间件
	p.ProxyFlow(ctx)
}

func main() {
        //......
	//注册插件
	p.SetPlugins()
       //......
}