深入理解Go标准库-http server的启动

如何用最少的代码创建一个HTTP server?

go 复制代码
package main

import (
	"net"
	"net/http"
)

func main() {
	// 方式1
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
	 	panic(err)
	}
}

点开http.ListenAndServe可以看到函数只是创建了Server类型并调用server.ListenAndServe()

所以下面的和上面的代码没有区别

go 复制代码
package main

import (
	"net"
	"net/http"
)

func main() {
	// 方式2
	server := &http.Server{Addr: ":8080"}
	err := server.ListenAndServe()
	if err != nil {
		panic(err)
	}
}

ListenAndServe()如其名会干两件事

  • 监听一个端口,即Listen的过程
  • 处理进入端口的连接,即Serve的过程

所以下面的代码和上面的代码也没区别

go 复制代码
package main

import (
	"net"
	"net/http"
)

func main() {
    // 方式3
	ln, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}

	server := &http.Server{}
	err = server.Serve(ln)
	if err != nil {
		panic(err)
	}
}

一张图展示三种使用方式

路由?no!Handler!

按上面的代码启动HTTP Server没有太大意义,因为我们还没有设定路由,所以无法正常响应请求

shell 复制代码
$ curl  127.0.0.1:8080 
404 page not found

暂停思考一下,服务器返回404是因为没有设定路由么?no,no,no,你需要转变一下思维。服务器返回404不是因为我们没有设置路由 ,而是因为没有设置请求的处理程序 ,这个处理程序在Go中叫作:Handler

go 复制代码
type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

🌲 怎么定义请求的处理程序?

由上可知,仅需要实现ServeHTTP(ResponseWriter, *Request)接口即可

注意,示例代码没有判断任何路由(PATH)

go 复制代码
type handlerImp struct {
}

func (imp handlerImp) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method == "GET" {
		w.Write([]byte("Receive GET request"))
		return
	}
	if r.Method == "POST" {
		w.Write([]byte("Receive POST request"))
		return
	}
	return
}

🌲 怎么设置请求的处理程序?

三种方式本质上都是把自定义的Handler赋值到ServerHandler属性中

go 复制代码
func main() {
	// 方式1
	// err := http.ListenAndServe(":8080", handlerImp{})
	// if err != nil {
	// 	panic(err)
	// }

	// 方式2
	// server := &http.Server{Addr: ":8080", Handler: handlerImp{}}
	// err := server.ListenAndServe()
	// if err != nil {
	// 	panic(err)
	// }

	// 方式3
	ln, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}

	server := &http.Server{Handler:handlerImp{}}
	err = server.Serve(ln)
	if err != nil {
		panic(err)
	}
}

🌲 设置请求的处理程序之后的效果

handlerImp只针对Method做了不同的响应,没有对PATH做任何的判断,所以无论请求什么样的路径都能拿到一个预期的响应。

bash 复制代码
$ curl  -X POST 127.0.0.1:8080/foo
Receive POST request%  

$ curl  127.0.0.1:8080/foo/bar 
Receive GET request%  

此时再体会一下这句话:我们设置的不是路由 ,而是设置请求的处理程序

再聊Handler

go 复制代码
type handlerImp struct {
}

func (imp handlerImp) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method == "GET" {
		w.Write([]byte("Receive GET request"))
		return
	}
	if r.Method == "POST" {
		w.Write([]byte("Receive POST request"))
		return
	}
	return
}

如上所述,无论任何PATH,任何Method等,所有的请求都会被handlerImp.ServeHTTP处理。

我们可以判断PATH、Method等,根据不同的请求特征执行不同的逻辑,并且全部在这一个函数中全部完成

很明显,这违反了高内聚,低耦合的编程范式

停下来思考下,如何编写一个高内聚,低耦合的handlerImp.ServeHTTP,使之针对不同HTTP请求执行不同的逻辑呢

go 复制代码
type handlerImp struct {
}

func (imp handlerImp) handleMethodGet(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive GET request"))
	return
}

func (imp handlerImp) handleMethodPost(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive POST request"))
	return
}

func (imp handlerImp) handlePathFoo(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive path foo"))
	return
}

func (imp handlerImp) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/foo" {
		imp.handlePathFoo(w, r)
		return
	}
	if r.Method == "GET" {
		imp.handleMethodGet(w, r)
		return
	}
	if r.Method == "POST" {
		imp.handleMethodPost(w, r)
		return
	}
	return
}

如果你的答案和上面的代码类似,那么我对于这段代码的点评是:不太高明☹️

🌲 如何编写一个高内聚,低耦合的ServeHTTP,针对不同HTTP请求执行不同的逻辑?

不知道你有没有听过设计模式中,组合模式。没有了解可以去了解下,或者看下图

经过组合模式重新设计的handlerImp,已经不再包含具体的逻辑了,它先搜索有没有针对PATH处理的逻辑,再搜索有没有针对Method处理的逻辑,它专注于逻辑分派,它是组合模式中的容器

容器(Container):容器接收到请求后会将工作分配给自己的子项目, 处理中间结果, 然后将最终结果返回给客户端。

go 复制代码
type handlerImp struct {
	pathHandlers   map[string]http.Handler
	methodHandlers map[string]http.Handler
}

func NewHandlerImp() handlerImp {
	return handlerImp{
		pathHandlers:   make(map[string]http.Handler),
		methodHandlers: make(map[string]http.Handler),
	}
}

func (imp handlerImp) AddPathHandler(path string, h http.Handler) {
	imp.pathHandlers[path] = h
}

func (imp handlerImp) AddMethodHandler(method string, h http.Handler) {
	imp.methodHandlers[method] = h
}

func (imp handlerImp) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if h, ok := imp.pathHandlers[r.URL.Path]; ok {
		h.ServeHTTP(w, r)
		return
	}

	if h, ok := imp.methodHandlers[r.Method]; ok {
		h.ServeHTTP(w, r)
		return
	}

	return
}

重新设计的handlerImp不执行逻辑,实际的逻辑被分离到每一个叶子结点中,而每一个叶子结点也都实现了ServeHTTP函数,即Handler接口

go 复制代码
type PathFoo struct {
}

func (m PathFoo) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive path foo"))
	return
}

type MethodGet struct {
}

func (m MethodGet) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive GET request"))
	return
}

type MethodPost struct {
}

func (m MethodPost) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive POST request"))
	return
}

再次强调,通过对组合模式的运用,我们把逻辑分派的功能聚合到handlerImp,把具体的逻辑聚合到PathFooMethodGetMethodPost

go 复制代码
func main() {
	// 方式3
	ln, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}

	h := NewHandlerImp()
	h.AddMethodHandler("GET", MethodGet{})
	h.AddMethodHandler("POST", MethodPost{})
	h.AddPathHandler("/foo", PathFoo{})

	server := &http.Server{Handler: h}
	err = server.Serve(ln)
	if err != nil {
		panic(err)
	}
}

一些Handlers

上面实现的handlerImp利用组合设计模式,已经能针对Path和Method设定和处理不同的逻辑,但整体功能略显简单。有哪些可以供我们使用且功能强大的Handlers呢?

http.ServeMux

Go标准库中就提供了一个Handler实现叫作http.ServeMux

⚠️ 当前(go1.21.*)版本仅支持匹配Path,但目前已经在讨论支持Method匹配和占位符了:net/http: add methods and path variables to ServeMux patterns #60227

使用的方式如下

http.ServeMux提供两个函数用于注册不同Path的处理函数

  • ServeMux.Handle 接收的是Handler接口实现
  • ServeMux.HandleFunc 接收的是匿名函数
go 复制代码
type PathBar struct {
}

func (m PathBar) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive path bar"))
	return
}

func main() {
	// 方式3
	ln, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}

	mx := http.NewServeMux()
	mx.Handle("/bar/", PathBar{})
	mx.HandleFunc("/foo", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Receive path foo"))
	})

	server := &http.Server{Handler: mx}
	err = server.Serve(ln)
	if err != nil {
		panic(err)
	}
}

代码mx.Handle("/bar/", PathBar{})/bar//结尾,所以它可以匹配/bar/*所有的Path

关于http.ServeMux的细节不是本篇重点,后续会单独介绍

🌲 默认的Handler

因为是标准库内置的实现,当没有设置http.Server.Handler属性时,http.Server就会使用一个全局的变量DefaultServeMux *ServeMux来作为http.Server.Handler的值

go 复制代码
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

http包同时提供了两个函数可以在DefaultServeMux注册不同Path的处理函数

go 复制代码
func main() {
	http.Handle("/bar/", PathBar{})
	http.HandleFunc("/foo", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Receive path foo"))
	})

	// 方式1
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		panic(err)
	}
}

http.Handle 接收的是Handler接口实现,对应的是

go 复制代码
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

http.HandleFunc 接收的是匿名函数,对应的是

go 复制代码
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	DefaultServeMux.HandleFunc(pattern, handler)
}

gorilla/mux

gorilla/mux是一个相当流行的第三方库,用法这里简单写下

除了经典的HandleHandleFunc函数,gorilla/mux还提供了MethodsSchemesHost等非常复杂的功能

但无论多复杂,其一定包含了ServeHTTP函数,即实现了Handler接口

go 复制代码
func main() {
	r := mux.NewRouter()
    r.Handle("/foo/{bar}", PathBar{})
	r.Handle("/bar/", PathBar{})
	r.HandleFunc("/foo", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Receive path foo"))
	})
	r.Methods("GET").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Receive GET request"))
	})

	// 方式1
	err := http.ListenAndServe(":8080", r)
	if err != nil {
		panic(err)
	}
}

其他

还有很多其他优秀的mux实现,具体可以参考各自的官方文档。

github.com/go-chi/chi star 15.9k

github.com/julienschmi... star 15.6k

关于Go标准库、第三方库中这些结构的关系通过下图展示

再聊组合模式

无论是官方的http.ServeMux,还是一些第三方库,实现上大多使用了组合设计模式

组合模式的魔力还不止于此。思考一下这个场景:目前已经存在路由servemux/*,并且使用了ServeMux

go 复制代码
mx := http.NewServeMux()
mx.Handle("/servemux/bar/", PathBar{})
mx.HandleFunc("/servemux/foo", func(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Receive servemux path foo"))
})

但此时还有另外一组路由/gorilla/*,使用了开源库gorilla/mux

go 复制代码
r := mux.NewRouter()
r.Handle("/gorilla/bar/", PathBar{})
r.HandleFunc("/gorilla/foo", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Receive gorilla path foo"))
})

如何启动这样的服务器呢?

go 复制代码
func main() {
	mx := http.NewServeMux()
	mx.Handle("/servemux/bar/", PathBar{})
	mx.HandleFunc("/servemux/foo", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Receive servemux path foo"))
	})

	r := mux.NewRouter()
	r.Handle("/gorilla/bar/", PathBar{})
	r.HandleFunc("/gorilla/foo", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Receive gorilla path foo"))
	})

	h := http.NewServeMux()
	h.Handle("/servemux/", mx)
	h.Handle("/gorilla/", r)

	// 方式1
	err := http.ListenAndServe(":8080", h)
	if err != nil {
		panic(err)
	}
}

利用组合设计模式,h := http.NewServeMux()作为新的容器,将不同的路由分配给另外两个容器

  • mx := http.NewServeMux()
  • r := mux.NewRouter()

总结

本文主要介绍了Go http server的启动方式,重点介绍了http server的请求处理器

go 复制代码
type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

别看它仅包含一个方法,但在组合模式的加成下,可以实现千变万化的形态。

除了Go标准库中提供了http.ServeMux还有一系列开源库gorilla/muxgo-chi/chijulienschmidt/httprouterHandler进行了实现。

每一个库具有的能力、使用方式、性能不同,但万变不离其宗,都绕不开组合模式和Handler接口


✨ 微信公众号【凉凉的知识库】同步更新,欢迎关注获取最新最有用的后端知识 ✨

参考

相关推荐
Rverdoser31 分钟前
RabbitMQ的基本概念和入门
开发语言·后端·ruby
Tech Synapse1 小时前
Java根据前端返回的字段名进行查询数据的方法
java·开发语言·后端
.生产的驴1 小时前
SpringCloud OpenFeign用户转发在请求头中添加用户信息 微服务内部调用
spring boot·后端·spring·spring cloud·微服务·架构
微信-since811922 小时前
[ruby on rails] 安装docker
后端·docker·ruby on rails
代码吐槽菌3 小时前
基于SSM的毕业论文管理系统【附源码】
java·开发语言·数据库·后端·ssm
豌豆花下猫4 小时前
Python 潮流周刊#78:async/await 是糟糕的设计(摘要)
后端·python·ai
YMWM_4 小时前
第一章 Go语言简介
开发语言·后端·golang
码蜂窝编程官方4 小时前
【含开题报告+文档+PPT+源码】基于SpringBoot+Vue的虎鲸旅游攻略网的设计与实现
java·vue.js·spring boot·后端·spring·旅游
hummhumm4 小时前
第 25 章 - Golang 项目结构
java·开发语言·前端·后端·python·elasticsearch·golang
J老熊4 小时前
JavaFX:简介、使用场景、常见问题及对比其他框架分析
java·开发语言·后端·面试·系统架构·软件工程