Go语言中处理HTTP请求主要和两个东西相关：ServeMux和Handler。
-
路由器（ServeMux）：本质上是一个HTTP请求路由器（或者叫多路复用器，Mutiplexor）。它把收到的请求与一组预先定义的URL路径列表做对比，然后在匹配到路径的时候调用关联的处理器
-
处理器（Handler）：负责输出HTTP响应的头和响应体。任何满足了http.Handler接口的对象都可以作为一个处理器。通俗的说，对象只要实现了如下签名的ServeHTTP方法即可：
ServeHTTP(http.ResponseWriter, *http.Request)Go语言的HTTP包自带了几个函数用作简单的处理器，比如FileServer，NotFoundHandler和RedirectHandler。看一个简单的例子：
package main
import (
"log"
"net/http"
)
func main() {
mux := http.NewServeMux()
rh := http.RedirectHandler("http://example.org", 307)
mux.Handle("/foo", rh)
log.Println("Listening...")
http.ListenAndServe(":3000", mux)
}-
在main函数中使用http.NewServeMux函数创建一个空的ServeMux
-
使用http.RedirectHandler函数创建一个新的处理器，这个处理器会对收到的所有请求，都执行307重定向操作到http://example.org。
-
接下来我们使用ServeMux.Handle函数将处理器注册到新创建的ServeMux，所以它在URL路径/foo上收到的所有请求都交给这个处理器。
-
最后创建一个新的服务器，通过http.ListenAndServe函数监听所有进入的请求，通过传递刚才创建的ServeMux来为请求去匹配对应的处理器。
注意到ListenAndServe的函数签名是ListenAndServe(addr string, handler Handler)，但是第二个参数我们传递的是个ServeMux。
原因在于ServeMux也有ServeHTTP方法，因此它也是个合法的Handler。
将ServerMux用作一个特殊的Handler是一种简化。它不是自己输出响应，而是将请求传递注册到其他的Handler。Go中将Handler链在一起是非常普遍的用法。
接下来我们创建一个自定义的处理器，功能是以特定格式输出当前的本地时间：
type timeHandler struct {
format string
}
func (th *timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(th.format)
w.Write([]byte("The time is: " + tm))
}我们创建了一个对象（本例中时timerHandler结构体，也可以是一个字符串，一个函数或者任意的东西），并在这个对象上实现了一个ServeHTTP(http.ResponseWriter, *http.Request)签名的方法，这就是创建一个处理器的完整过程。
Handler的定义
type Handler interface {
ServeHTTP(ResponseWriter, *Request) // 路由实现器
}package main
import (
"log"
"net/http"
"time"
)
type timeHandler struct {
format string
}
func (th *timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(th.format)
w.Write([]byte("The time is: " + tm))
}
func main() {
mux := http.NewServeMux()
th := &timeHandler{format: time.RFC1123}
mux.Handle("/time", th)
log.Println("Listening...")
http.ListenAndServe(":3000", mux)
}main函数中，我们像初始化一个常规的结构体一样，初始化了timeHandler，用 & 符号获得了其地址。随后，像之前的例子一样，我们使用 mux.Handle 函数来将其注册到 ServerMux。
现在当我们运行这个应用，ServerMux 将会将任何对 /time的请求直接交给 timeHandler.ServeHTTP 方法处理。
同时可以在多个路由中轻松的复用timeHandler：
func main() {
mux := http.NewServeMux()
th1123 := &timeHandler{format: time.RFC1123}
mux.Handle("/time/rfc1123", th1123)
th3339 := &timeHandler{format: time.RFC3339}
mux.Handle("/time/rfc3339", th3339)
log.Println("Listening...")
http.ListenAndServe(":3000", mux)
}对于简单的情况，定义一个新的有ServerHTTP方法的自定义类型有些麻烦。Go提供了另外一种方式，通过借助http.HandlerFunc类型来让一个常规函数满足作为一个Handler的接口条件。
HandlerFunc的实现
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}任何由func(http.ResponseWriter, *http.Request)签名的函数都能转化为一个HandlerFunc类型。由于HandlerFunc对象内置了ServeHTTP方法，后者便可以作为handler注册到ServerMux中。
package main
import (
"log"
"net/http"
"time"
)
func timeHandler(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(time.RFC1123)
w.Write([]byte("The time is: " + tm))
}
func main() {
mux := http.NewServeMux()
// Convert the timeHandler function to a HandlerFunc type
th := http.HandlerFunc(timeHandler)
// And add it to the ServeMux
mux.Handle("/time", th)
log.Println("Listening...")
http.ListenAndServe(":3000", mux)
}实际上，将一个函数转换成HandlerFunc后注册到ServeMux是很普遍的用法，所以Go中提供了一个便捷方式：ServerMux.HandlerFunc方法。
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/time", timeHandler)
log.Println("Listening...")
http.ListenAndServe(":3000", mux)
}绝大多数情况下这种用函数当处理器的方式工作的很好。但是当事情开始变得更复杂的时候，就会有些产生一些限制了。
你可能已经注意到了，跟之前的方式不同，我们不得不将时间格式硬编码到 timeHandler 的方法中。如果我们想从 main() 函数中传递一些信息或者变量给处理器该怎么办？
一个优雅的方式是将我们处理器放到一个闭包中，将我们要使用的变量带进去：
package main
import (
"log"
"net/http"
"time"
)
func timeHandler(format string) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(format)
w.Write([]byte("The time is: " + tm))
}
return http.HandlerFunc(fn)
}
func main() {
mux := http.NewServeMux()
th := timeHandler(time.RFC1123)
mux.Handle("/time", th)
log.Println("Listening...")
http.ListenAndServe(":3000", mux)
}timeHandler 函数现在有了个更巧妙的身份。除了把一个函数封装成 Handler(像我们之前做到那样)，我们现在使用它来返回一个处理器。这种机制有两个关键点：
-
首先是创建了一个fn，这是个匿名函数，将 format 变量封装到一个闭包里。闭包的本质让处理器在任何情况下，都可以在本地范围内访问到 format 变量。
-
其次我们的闭包函数满足 func(http.ResponseWriter, *http.Request) 签名。如果你记得之前我们说的，这意味我们可以将它转换成一个HandlerFunc类型（满足了http.Handler接口）。我们的timeHandler 函数随后转换后的 HandlerFunc 返回。
在上面的例子中我们已经可以传递一个简单的字符串给处理器。但是在实际的应用中可以使用这种方法传递数据库连接、模板组，或者其他应用级的上下文。使用全局变量也是个不错的选择，还能得到额外的好处就是编写更优雅的自包含的处理器以便测试。
类似的写法还有
func timeHandler(format string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(format)
w.Write([]byte("The time is: " + tm))
})
}做隐式转换
func timeHandler(format string) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(format)
w.Write([]byte("The time is: " + tm))
}
}DefauleServeMux就是我们之前使用的ServerMux，只是它随着net/http包初始化的时候自动被初始化了而已。
var DefaultServeMux = NewServeMux()net/http包提供了一组快捷方式来配合DefaultServeMux：http.Handle和http.HandlerFunc。这些函数与我们之前看过类似的名称和函数功能一样，唯一不同的是他们将处理器注册到DefaultServerMux，而之前我们是注册到自己创建的ServeMux。
ListenAndServe在没有提供其他的处理器的情况下（也就是第二个参数传nil），内部会使用DefaultServeMux。
使用DefaultServeMux的例子
package main
import (
"log"
"net/http"
"time"
)
func timeHandler(format string) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
tm := time.Now().Format(format)
w.Write([]byte("The time is: " + tm))
}
return http.HandlerFunc(fn)
}
func main() {
// Note that we skip creating the ServeMux...
var format string = time.RFC1123
th := timeHandler(format)
// We use http.Handle instead of mux.Handle...
http.Handle("/time", th)
log.Println("Listening...")
// And pass nil as the handler to ListenAndServe.
http.ListenAndServe(":3000", nil)看一下Go内置的路由实现，ServeMux的结构如下：
type ServeMux struct {
mu sync.RWMutex // 锁，由于请求涉及到并发处理，因此这里需要一个锁机制
m map[string]muxEntry // 路由规则，一个 string 对应一个 mux 实体，这里的 string 就是注册的路由表达式
hosts bool // 是否在任意的规则中带有 host 信息
}muxEntry的定义
type muxEntry struct {
explicit bool // 是否精确匹配
h Handler // 这个路由表达式对应哪个 handler
pattern string // 匹配字符串
}使用Golang内置的路由器ServeMux，本质是将路由表达式和对应的处理器存储到一个map中
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
if pattern == "" {
panic("http: invalid pattern")
}
if handler == nil {
panic("http: nil handler")
}
if _, exist := mux.m[pattern]; exist {
panic("http: multiple registrations for " + pattern)
}
if mux.m == nil {
mux.m = make(map[string]muxEntry)
}
e := muxEntry{h: handler, pattern: pattern}
mux.m[pattern] = e
if pattern[len(pattern)-1] == '/' {
mux.es = appendSorted(mux.es, e)
}
if pattern[0] != '/' {
mux.hosts = true
}
}func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
if r.RequestURI == "*" {
w.Header().Set("Connection", "close")
w.WriteHeader(StatusBadRequest)
return
}
h, _ := mux.Handler(r)
h.ServeHTTP(w, r)
}如上所示路由器接收到请求之后，如果是 * 那么关闭链接，不然调用 mux.Handler(r) 返回对应设置路由的处理 Handler，然后执行 h.ServeHTTP(w, r)
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
if r.Method != "CONNECT" {
if p := cleanPath(r.URL.Path); p != r.URL.Path {
_, pattern = mux.handler(r.Host, p)
return RedirectHandler(p, StatusMovedPermanently), pattern
}
}
return mux.handler(r.Host, r.URL.Path)
}
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
mux.mu.RLock()
defer mux.mu.RUnlock()
// Host-specific pattern takes precedence over generic ones
if mux.hosts {
h, pattern = mux.match(host + path)
}
if h == nil {
h, pattern = mux.match(path)
}
if h == nil {
h, pattern = NotFoundHandler(), ""
}
return
}
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
// Check for exact match first.
v, ok := mux.m[path]
if ok {
return v.h, v.pattern
}
// Check for longest valid match. mux.es contains all patterns
// that end in / sorted from longest to shortest.
for _, e := range mux.es {
if strings.HasPrefix(path, e.pattern) {
return e.h, e.pattern
}
}
return nil, ""
}根据用户请求的 URL 和路由器里面存储的 map 去匹配，当匹配到之后返回存储的 handler，调用这个 handler 的 ServeHTTP 接口执行相应的函数。