Go之Http包的服务端介绍

js_content">

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

一、总体介绍

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

https://img-blog.csdnimg.cn/img_convert/fae8ac42bfb72e0943160d2a8af02032.png" />

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方法来处理请求，源码如下：

go">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也可以自己实现，例子如下：

go">package main
import (
    "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.自定义处理器，例子如下：

go">package main
import (
  "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 方法，后者可以聪明又方便的调用我们最初提供的函数内容。例子如下所示：

go">package main
import (
  "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://img-blog.csdnimg.cn/img_convert/a4e147c59e80ac39021502c278bda149.png" />

参考文档：

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