【Golang 标准库】package net/http

我们在使用 Go 语言的 http 服务时，第一步通常是绑定一个处理函数到相应的路由地址。

http.HandleFunc("/sayhello", sayhellofunc)

这样，当用户访问该路由地址时，就会调用我们绑定的处理函数。

可是，处理函数的实现各不相同，http 包内部是如何统一表示这些处理函数的呢？

从路由绑定函数开始探究

首先，我们从文章一开始的路由绑定代码开始挖掘，来看看传入的 sayhellofunc 究竟经过了怎样的加工？

// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

可以看到，参数 handler 必须是一个满足签名要求的函数实例，让我们继续往下看。

// HandleFunc registers the handler function for the given pattern.
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    mux.Handle(pattern, HandlerFunc(handler))
}

原来，函数内部通过 HandlerFunc() 对 handler 做了类型转换。

HandlerFunc 具体实现

我们来看下 HandlerFunc 类型的具体定义

// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request)

所以，HandlerFunc 是通过 func(ResponseWriter, *Request) 定义的一种新类型，这也合理，毕竟后者实在是太长了，每次都要写这么一大串肯定不如定义一个专门的类型方便。

Handler 接口

实际上，转换成 HandlerFunc 类型的好处不只是简化名称，转换后的函数会自动拥有该类型定义的的ServeHTTP方法。

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

该方法内部调用了函数自身。并且通过这种方式实现了 Handler 接口。

// A Handler responds to an HTTP request.
//
// ServeHTTP should write reply headers and data to the ResponseWriter
// and then return. Returning signals that the request is finished; it
// is not valid to use the ResponseWriter or read from the
// Request.Body after or concurrently with the completion of the
// ServeHTTP call.
//
// Depending on the HTTP client software, HTTP protocol version, and
// any intermediaries between the client and the Go server, it may not
// be possible to read from the Request.Body after writing to the
// ResponseWriter. Cautious handlers should read the Request.Body
// first, and then reply.
//
// Except for reading the body, handlers should not modify the
// provided Request.
//
// If ServeHTTP panics, the server (the caller of ServeHTTP) assumes
// that the effect of the panic was isolated to the active request.
// It recovers the panic, logs a stack trace to the server error log,
// and either closes the network connection or sends an HTTP/2
// RST_STREAM, depending on the HTTP protocol. To abort a handler so
// the client sees an interrupted response but the server doesn't log
// an error, panic with the value ErrAbortHandler.
type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

这样，处理函数都可以看做 Handler 接口，并通过 ServeHTTP 方法调用处理逻辑，这样就实现了对处理函数的统一表示。

下面我们透过分析 http 包中路由能力的实现，来看看面向接口类型来设计有什么好处。

路由能力的实现

让我们来看下 http 包究竟如何实现根据地址路由的。

// serverHandler delegates to either the server's Handler or
// DefaultServeMux and also handles "OPTIONS *" requests.
type serverHandler struct {
    srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    if req.RequestURI == "*" && req.Method == "OPTIONS" {
        handler = globalOptionsHandler{}
    }
    handler.ServeHTTP(rw, req)
}

首先，所有的请求都会经过 serverHandler。函数内部调用了mux.ServeHTTP方法。

// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
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)
}

函数内实际上调用了 mux.Handler 方法，该函数通过请求的 url 等信息匹配对应的 handler，并执行 handler 的处理逻辑。

// Handler returns the handler to use for the given request,
// consulting r.Method, r.Host, and r.URL.Path. It always returns
// a non-nil handler. If the path is not in its canonical form, the
// handler will be an internally-generated handler that redirects
// to the canonical path. If the host contains a port, it is ignored
// when matching handlers.
//
// The path and host are used unchanged for CONNECT requests.
//
// Handler also returns the registered pattern that matches the
// request or, in the case of internally-generated redirects,
// the pattern that will match after following the redirect.
//
// If there is no registered handler that applies to the request,
// Handler returns a ``page not found'' handler and an empty pattern.
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {

 // CONNECT requests are not canonicalized.
 if r.Method == "CONNECT" {
  // If r.URL.Path is /tree and its handler is not registered,
  // the /tree -> /tree/ redirect applies to CONNECT requests
  // but the path canonicalization does not.
  if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok {
   return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
  }

  return mux.handler(r.Host, r.URL.Path)
 }

 // All other requests have any port stripped and path cleaned
 // before passing to mux.handler.
 host := stripHostPort(r.Host)
 path := cleanPath(r.URL.Path)

 // If the given path is /tree and its handler is not registered,
 // redirect for /tree/.
 if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
  return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
 }

 if path != r.URL.Path {
  _, pattern = mux.handler(host, path)
  u := &url.URL{Path: path, RawQuery: r.URL.RawQuery}
  return RedirectHandler(u.String(), StatusMovedPermanently), pattern
 }

 return mux.handler(host, r.URL.Path)
}

// handler is the main implementation of Handler.
// The path is known to be in canonical form, except for CONNECT methods.
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
}

// Find a handler on a handler map given a path string.
// Most-specific (longest) pattern wins.
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, ""
}

最终，由 match 函数在 map 中匹配对应的 handler。

总结

本文主要分析了 Go 语言的 http 包如何对传入的处理函数进行包装，以实现面向抽象的设计。

可以看到，在编写路由代码时，使用的都是 Handler 接口类型。这样我们的处理函数不一定非得是固定的函数签名，只要实现了相应的方法即可。

Go 对上述过程的实现都封装在 net/http 包的 server.go 文件中。这种将普通函数标准化的方式，也是 adapter（适配器）模式的一种应用。