http.ServeMux

HTTP协议全称超文本传输协议（HyperText Transfer Protocol）是互联网上应用最为广泛的一种网络协议，它详细规定了浏览器和WWW服务器之间通信的规则，通过Internet传送WWW文档的数据传送协议。

Web服务是HTTP协议的一个服务，HTTP协议承载在TCP协议之上。Web服务工作流程

1. 客户端通过TCP/IP建立到服务器的TCP连接
2. 客户端向服务端发送HTTP协议请求包以请求服务端资源文档
3. 服务端向客户端发送HTTP协议应答包，若请求资源包含动态数据，服务端会调用动态语言解释引擎负责处理，处理后会将结果返还客户端。
4. 客户端与服务端断开连接，客户端解释HTML文档后再屏幕渲染图形结果。

基于HTTP构建的服务标准模型包括客户端和服务端，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个阶段

1. 注册路由：提供URL模式和处理函数之间的映射
2. 提供服务：开启对客户端的监听并接收请求

例如：创建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)
}