HTTP协议全称超文本传输协议（HyperText Transfer Protocol）是互联网上应用最为广泛的一种网络协议，它详细规定了浏览器和WWW服务器之间通信的规则，通过Internet传送WWW文档的数据传送协议。
Web服务是HTTP协议的一个服务，HTTP协议承载在TCP协议之上。Web服务工作流程
- 客户端通过TCP/IP建立到服务器的TCP连接
- 客户端向服务端发送HTTP协议请求包以请求服务端资源文档
- 服务端向客户端发送HTTP协议应答包，若请求资源包含动态数据，服务端会调用动态语言解释引擎负责处理，处理后会将结果返还客户端。
- 客户端与服务端断开连接，客户端解释HTML文档后再屏幕渲染图形结果。
基于HTTP构建的服务标准模型包括客户端和服务端，HTTP请求从客户端发出，服务端接收到请求后进行处理，然后将响应返回给客户端。
HTTP服务端核心工作是如何接收来自客户端的请求，并向客户端返回响应。当HTTP服务器接收到客户端请求时，首先会进入路由模块，路由又称为服务复用器（Multiplexer），路由的工作在于请求找到对应的处理器（Handler），处理器对接收到的请求进行对应处理后，构建响应并返回给客户端。
http.Client -> http.Request -> Multiplexer(router)->http.Handler ->Response -> http.Client
Go语言通过引入net/http包来实现HTTP网络访问，并提供HTTP客户端和服务端的实现。
-
net/http包可很方便地搭建Web服务 -
net/http包能对路由、静态资源、模板、Cookie等数据进行设置和操作。
创建服务
创建HTTP服务需经过2个阶段
- 注册路由：提供URL模式和处理函数之间的映射
- 提供服务：开启对客户端的监听并接收请求
例如：创建HTTP服务
func main() {
//创建处理程序
mux := http.NewServeMux()
mux.Handle("/", http.RedirectHandler("http://www.baidu.com", 307))
//创建服务对象
srv := http.Server{}
srv.Addr = ":8800"
srv.Handler = mux
//监听端口接收连接
if err := srv.ListenAndServe(); err != nil {
panic(err)
}
}
注册路由
- 注册路由目的是为了提供URL模式和处理函数的映射
- 注册一个URL到
http.ServeMux结构实例上的http.Handler对象上
理解HTTP服务关键点在于路由器和处理器
type Handler interface
type ServeMux struct
| 关键点 | 标识 | 代码 | 类型 |
|---|---|---|---|
| 处理器 | Handler | http.Handler | 接口 |
| 服务复用器 | Multiplexer | http.ServeMux | 结构体 |
服务复用器
- 服务复用器有多种称呼，如请求路由器、多路转接器、多路复用器等。
- 服务复用器负责将每个请求的URL与注册模式列表进行匹配，并调用和URL最佳匹配模式的处理器。
处理器
- 处理器负责输出HTTP响应的头和正文
http.ServeMux
-
http.ServeMux本质上是一个HTTP请求路由器 -
http.ServeMux实现了http.Handler接口方法http.ServeHTTP()
type ServeMux struct {
mu sync.RWMutex//读写互斥锁，并发请求需锁机制
m map[string]muxEntry//路由规则，一个路由表达式对应一个复用器实体
es []muxEntry // slice of entries sorted from longest to shortest.
hosts bool // 是否在任意路由规则中携带主机信息
}
| 字段 | 描述 |
|---|---|
| mu | 读写互斥锁，并发请求需锁机制。 |
| m | 路由规则，一个字符串的路由表达式对应一个多路复用器入口实体。 |
| hosts | 是否在任意规则中携带主机信息 |
http.ServeMux内部使用一个map映射来保存所有处理器，http.muxEntry是一个多路复用器入口实体。
type muxEntry struct {
h Handler //路由表达式对应的处理器
pattern string //匹配字符串
}
可以发现在http.muxEntry字段中存在着http.Handler接口类型的h
type Handler interface {
ServeHTTP(ResponseWriter, *Request) //路由实现
}
虽然http.ServeMux也实现了http.ServerHTTP()算得上是一个http.Handler，但http.ServeMux的http.ServeHTTP()并非用来处理请求和响应，而是用来查找注册路由对应的处理器。
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
if r.RequestURI == "*" {
if r.ProtoAtLeast(1, 1) {
w.Header().Set("Connection", "close")
}
w.WriteHeader(StatusBadRequest)
return
}
h, _ := mux.Handler(r)
h.ServeHTTP(w, r)
}
当http.ServeMux路由器设置路由规则后，会通过它实现的ServeHTTP()完成请求的分发。当路由器接收到请求后若请求的URI为*则会关闭连接，否则会调用自身的Handler()来获取对应路由的处理器，最终通过调用h.ServeHTTP(w,r)实现对应路由的实现逻辑。
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
//...
return mux.handler(host, r.URL.Path)
}
路由器会根据用户请求的URL路径去匹配自身存储的在map中的handler，最终调用匹配到的handler的ServeHTTP()以实现执行对应路由的处理函数。
创建http.ServeMux实例的方式有两种
- 直接使用默认的
http.DefaultServeMux对象 - 使用
http.NewServeMux()自定义创建
http.DefaultServeMux
http.DefaultServeMux是默认的http.ServeMux，会随着net/http包初始化而被自动初始化。
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux
当http.ListenAndServe()在没有提供其他处理器的情况下，即它的入参handler为nil时内部会使用http.DefaultServeMux。
func main() {
//注册路由
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(time.Now().Format(time.RFC3339)))
})
//监听端口接收连接
if err := http.ListenAndServe(":8900", nil); err != nil {
panic(err)
}
}
net/http包提供了一组快捷的注册路由的函数http.Handle()、http.HandleFunc()来配置http.DefaultServeMux，快捷函数会将处理器注册到http.DefaultServeMux。
func Handle(pattern string, handler Handler) {
DefaultServeMux.Handle(pattern, handler)
}
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
二者之间的区别在于handler参数上
http.Handle()的handler是一个http.Handler接口实例，也就是说传入的handler必须要自己提前实现http.Handler接口的ServerHTTP(ResponseWriter, *Request)方法。
例如：将处理器放入闭包中，将参数传入处理器。
func defaultHandler(format string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r*http.Request) {
w.Write([]byte(time.Now().Format(format)))
})
}
func main() {
handler := defaultHandler(time.RFC3339)
http.Handle("/", handler)
http.ListenAndServe(":3000", nil)
}
http.HandleFunc()的handler直接是一个原型为func(ResponseWriter, *Request)的函数，深入追踪会HandleFunc()会发现一个自定义的函数类型。
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
因此任何具有func(ResponseWriter, *Request)签名的函数都能转换成为一个http.HandlerFunc类型的对象。同时自定义的函数类型中已经实现了ServeHTTP()方法，因此它也是一个http.Handler。
例如：返回时使用一个到http.HandlerFunc类型的隐式转换
func defaultHandler(format string) http.HandlerFunc {
return func(rw http.ResponseWriter, rq *http.Request) {
rw.Write([]byte(time.Now().Format(format)))
}
}
func main() {
handler := defaultHandler(time.RFC3339)
http.Handle("/", handler)
http.ListenAndServe(":3000", nil)
}
http.NewServeMux
net/http包提供了http.NewServeMux()来创建一个自定义的http.ServeMux实例
func NewServeMux() *ServeMux
例如：调用http.NewServeMux()会创建服务复用器
mux := http.NewServeMux()
mux.Handle("/", http.RedirectHandler("http://www.baidu.com", 307))
http.ListenAndServe(":3000", mux)
例如：创建静态服务
func StaticHandler(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Printf("ip:%s, url:%s\n", r.RemoteAddr, r.RequestURI)
next.ServeHTTP(w, r)
})
}
func StaticServer(addr string, dirname string) {
handler := StaticHandler(http.FileServer(http.Dir(dirname)))
mux := http.NewServeMux()
mux.Handle("/", handler)
srv := &http.Server{
Addr: addr,
Handler: mux,
ReadTimeout: time.Second,
WriteTimeout: time.Second,
}
if err := srv.ListenAndServe(); err != nil {
log.Fatalf("static server %s error : %+v\n", addr, err)
}
log.Printf("static server %s running...\n", addr)
}
func main() {
StaticServer("127.0.0.1:8602", "/static/")
}
http.Handler
Go中没有继承、多态，可通过接口来实现。而接口则是定义声明的函数签名，任何结构体只要实现与接口函数签名相同的方法，即等同于实现了对应的接口。
-
net/http包实现的HTTP服务都是基于http.Handler接口进行处理的 - 任何结构体只要实现了
ServeHTTP()方法即可称之为处理器对象 -
http.ServeMux会使用处理器对象并调用ServeHTTP()方法来处理请求并返回响应 -
net/http包中自带处理程序包括FileServer、NotFoundHandler、RedirectHandler等
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
| 处理器 | 描述 |
|---|---|
| 处理器函数 | 具有func(ResponseWriter, *Request)签名的函数 |
| 处理器处理函数 | 经过http.HandlerFunc包装具有ServerHTTP()函数 |
| 处理器对象 | 直接实现了http.Handler接口ServerHTTP()方法的结构实例 |
例如：http.HandleFunc()处理函数实现实际上调用默认http.DefaultServeMux的HandleFunc()方法
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)){
DefaultServeMux.HandleFunc(pattern, handler)
}
例如：调用http.Handle()方法则第二个参数handle必须实现http.Handler接口的ServeHTTP()方法，也就是说只要具有ServeHTTP()签名方法即可作为处理器。
例如：自定义处理器
package main
import (
"net/http"
"time"
)
type TestHandler struct {
format string
}
func (t *TestHandler) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
rw.Write([]byte(time.Now().Format(t.format)))
}
func main() {
mux := http.NewServeMux()
th := &TestHandler{format: time.RFC3339}
mux.Handle("/", th)
http.ListenAndServe(":3000", mux)
}
http.HandlerFunc
http.HandlerFunc自身已实现http.Handler接口的ServeHTTP()方法，因此它也是一个处理器。
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
http.HandlerFunc的作用是将自定义函数转换为http.Handler处理器类型，当调用http.HandlerFunc(fn)后会强制将fn函数类型转换为http.HandlerFunc类型，这样fn函数就具有了ServeHTTP()方法，同时也就转换成为了一个http.Handler处理器。因此http.HandlerFunc又称为适配器。
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
