Go之Http包的服务端介绍

对于go的net/http包，主要分为两个部分，一部分是针对客户端的，一部分是针对服务端的，本篇文章主要介绍服务端这部分内容。

一、总体介绍

一个http消息的流程如下所示，其中红框部分是server部分的内容，主要包括两部分内容：ServerMux 和 Handler。

 

ServerMux 本质上是一个 HTTP 请求路由器(也叫多路复用器Multiplexor)。它把收到的请求与一组预先定义的 URL 路径列表做对比，然后在匹配到路径的时候调用关联的处理器（Handler）。

处理器（Handler）负责输出HTTP响应的头和正文,任何满足了http.Handler接口的对象都可作为一个处理器。

二、ServerMux介绍

ServerMux 本质上是一个 HTTP 请求路由器（或者叫多路复用器，Multiplexor）。它把收到的请求与一组预先定义的 URL 路径列表做对比，然后在匹配到路径的时候调用关联的处理器（Handler）。

1.Go中既可以使用内置的mutilplexer 也就是DefautServeMux，也可以自定义。Multiplexer路由的目的就是为了找到处理器函数（handler），后者将对request进行处理，同时构建response。

源码如下所示：

type ServeMux struct {    
    mu    sync.RWMutex  //锁，因为请求是并发处理的，所以这里需要锁机制    
    m     map[string]muxEntry //路由规则的map，一个string对应一个muxEntry    
    es    []muxEntry     hosts bool      
}
type muxEntry struct {    
    h       Handler    //string对应的处理器
    pattern string     //匹配的字符串
}

默认的DefaultServerMux是根据请求的URL与存储的map做匹配，匹配到了就返回对应的handler，然后调用该handler的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)}
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
    if r.Method == "CONNECT" { 
       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) 
    }
    host := stripHostPort(r.Host)
    path := cleanPath(r.URL.Path)
    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)  
      url := *r.URL  
      url.Path = path  
      return RedirectHandler(url.String(), StatusMovedPermanently), pattern  
    }
    return mux.handler(host, r.URL.Path)}
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {  
  mux.mu.RLock()   
  defer mux.mu.RUnlock()
  if mux.hosts {
        h, pattern = mux.match(host + path) 
  }
  if h == nil {
        h, pattern = mux.match(path) 
  }
  if h == nil {
        h, pattern = NotFoundHandler(), "" 
   } 
   return
}

2.当然ServerMux也可以自己实现，例子如下：

package mainimport (
    "fmt" 
   "net/http")
// 自定义一个多路复用器的结构
type MyTestMux struct{}
// 实现ServeHTTP方法
func (m MyTestMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 判断URL并转到对应的handler处理 
   if r.URL.Path == "/test" { 
       TestHandler(w, r) 
       return 
   }
   http.NotFound(w, r)
   return
}
func TestHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "This is Test page")
}

func main() {
   // 实例化一个自定义的路由器 
   mux := MyTestMux{}
   err := http.ListenAndServe(":9000", mux) // 这里指定使用自定义的mux
   if err != nil {
        fmt.Println(err) 
   }
}

 

三、处理器Handler

处理器（Handler）负责输出HTTP响应的头和正文,任何满足了http.Handler接口的对象都可作为一个处理器。通俗的说，对象只要有个如下签名的ServeHTTP方法即可，如下所示：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
   //路由具体实现
}

处理器的使用往往采用下面两种方式：

1.自定义处理器，例子如下：

package mainimport (
  "log" 
  "net/http"
)
type TestHandler struct {
  Data string /
/ 这里可以添加自己需要的数据内容
}
// 实现ServeHTTP函数
func (th *TestHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("The time is: " + th.Data))
}
func main() {
  mux := http.NewServeMux() // 新建一个自定义的mux
  th := &TesteHandler{Data: "test"}
  mux.Handle("/test", th) // 将handle添加一个th
  log.Println("Listening...")
  http.ListenAndServe(":9000", mux) // 关联成自定义的mux
}

2.通过http.HandlerFunc 将函数转换成处理器

任何有 func(http.ResponseWriter, *http.Request) 签名的函数都能转化为一个 HandlerFunc 类型。因为 HandlerFunc 对象内置了 ServeHTTP 方法，后者可以聪明又方便的调用我们最初提供的函数内容。例子如下所示：

package mainimport (
  "log" 
 "net/http" 
 "time"
)
func TestHandler(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("The Test is: " + "test"))
}
func main() {
  mux := http.NewServeMux()  // 将TestHandler转换成handler
  th := http.HandlerFunc(TestHandler)
  mux.Handle("/test", th)//添加到到handle中
  log.Println("Listening...") 
  http.ListenAndServe(":9000", mux)//关联成自定义的mux
}

四、服务端处理http请求的流程是什么样子的？

我们通过使用默认的DefautServeMux为例，来讲解下http服务端的处理流程，这里分析的是下面这种最常用的代码实现方式：

func TestHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Request.URL.Path: %s!", r.URL.Path[1:])
}
func main() {
    http.HandleFunc("/", TestHandler) 
    log.Fatal(http.ListenAndServe(":  9000", nil))
}

执行流程如下所示：

 

参考文档：

https://draveness.me/golang/docs/part4-advanced/ch09-stdlib/golang-net-http/#%E6%B3%A8%E5%86%8C%E5%A4%84%E7%90%86%E5%99%A8

https://www.jianshu.com/p/4e8cdf3b2f88

https://www.jianshu.com/p/16210100d43d

https://www.jianshu.com/p/be3d9cdc680b

https://studygolang.com/articles/9467

https://learnku.com/docs/build-web-application-with-golang/034-gos-http-package-detailed-solution/3171

 

---