关于go:41-Golang常用标准库nethttpserver

  Go语言创立HTTP服务还是十分不便的，基于http.Server几行代码就能实现，本篇文章次要介绍http.Server的根本应用形式以及HTTP申请解决流程。当然，目前很多web服务都基于gin框架实现，所以咱们也会简略介绍下gin框架的一些应用套路。

http.Server 概述

  基于http.Server只须要短短几行代码就能创立一个HTTP服务，最简略的只须要配置好监听地址，以及申请解决handler就能够了，如上面程序所示：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    server := &http.Server{
        Addr: "0.0.0.0:8080",
    }

    //注册路由（也就是申请解决办法），解决/ping申请，准确匹配（申请地址必须完全一致）
    http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello world"))
    })

    //启动HTTP服务
    err := server.ListenAndServe()
    if err != nil {
        fmt.Println(err)
    }
}

/*
curl http://127.0.0.1:8080/ping
hello world

curl http://127.0.0.1:8080/ping/1
404 page not found
*/

  如下面程序所示，http.Server.Addr设置HTTP服务监听地址，如果没有设置，默认监听80端口；http.HandleFunc函数用于注册路由，也就是申请对应的解决办法，有两个参数：第一个参数含意是pattern，有两种匹配形式，”/ping”为准确匹配即申请地址必须等于”/ping”，如申请”/ping/1″无奈匹配，而”/ping/”为前缀匹配，如申请”/ping/1″也会匹配胜利；第二个参数是函数类型，func(ResponseWriter, * Request)，ResponseWriter可用于向客户端返回数据，Request代表以后HTTP申请。

  函数http.Server.ListenAndServe用于启动HTTP服务，想想流程应该是怎么的呢？必定须要Listen吧（底层必定少不了socket，bind，listen三个零碎调用），其次呢？期待客户端连贯呗，也就是循环期待accept，一旦返回创立新的协程解决该客户端申请就行了（包含读取数据，解析HTTP申请，解决，返回数据）。还是比较简单的，整个流程的代码如下：

func (srv *Server) ListenAndServe() error {
    ln, err := net.Listen("tcp", addr)
    
    return srv.Serve(ln)
}

func (srv *Server) Serve(l net.Listener) error {

    for {
        rw, err := l.Accept()
        c := srv.newConn(rw)
        // 子协程解决申请
        go c.serve(connCtx)
    }
}

func (c *conn) serve(ctx context.Context) {

    for {
        //读取&解析HTTP申请
        w, err := c.readRequest(ctx)

        //解决HTTP申请
        serverHandler{c.server}.ServeHTTP(w, w.req)

        //完结&返回
        w.finishRequest()

        if !w.conn.server.doKeepAlives() {
            return
        }
    }
}

  整个流程框架其实非常简单，与咱们料想的基本一致，当然这里咱们省略了很多细节问题。如，c.serve函数主流程为什么是一个for循环呢？会屡次解决申请吗？当然是的，因为HTTP协定keepalive存在，客户端建设连贯之后，能够基于这一个连贯发送多个HTTP申请。而且，个别解决HTTP申请是不是都有超时工夫，如何解决超时问题咱们也省略了，咱们只关注都有哪些超时配置，这些配置都定义在http.Server构造，如下：

type Server struct {
    //读取HTTP申请head超时工夫
    ReadHeaderTimeout time.Duration
    //读取HTTP申请超时工夫
    ReadTimeout time.Duration

    //写申请响应超时工夫（在此之前必须向客户端返回响应数据），超时敞开连贯
    WriteTimeout time.Duration
    //闲暇长连贯超时工夫（留神如果没有设置，默认应用ReadTimeout），超时敞开连贯
    IdleTimeout time.Duration
}

  有两个超时配置须要关注下：WriteTimeout设置的是写申请响应超时工夫，也就是说从收到客户端申请开始，该工夫内必须向客户端返回响应数据，否则触发超时，敞开与客户端的连贯（划重点：可能会导致502或reset），所以这也是业务申请最大解决工夫；IdleTimeout设置的是闲暇长连贯超时工夫，也就是说解决完以后申请之后，Go服务期待下一个申请达到的最大工夫（在此时间段认为长连贯闲暇），超过该时间段，会敞开与客户端的长连贯（划重点：可能会导致502或reset），划重点，如果IdleTimeout没有设置，默认应用ReadTimeout。

  另外，留神解决HTTP申请时，是通过http.serverHandler.ServeHTTP函数解决的，而咱们创立HTTP服务设置申请解决办法是通过函数http.HandleFunc实现的，这之间有什么关系吗？Go语言HTTP申请处理器都必须实现接口http.Handler，该接口只定义了一个办法ServeHTTP：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

//http.serverHandler构造实现了http.Handler接口
type serverHandler struct {
    srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    // http.Server.Handler字段的类型就是 http.Handler，也就是说通过这个字段也能定义申请解决办法
    handler := sh.srv.Handler
    if handler == nil {
        //http.HandleFunc注册路由到全局DefaultServeMux
        handler = DefaultServeMux
    }

    //解决申请
    handler.ServeHTTP(rw, req)
}

  http.serverHandler构造实现了http.Handler接口（实现了办法ServeHTTP），该办法可依据申请地址，匹配对应的解决办法并执行。另外留神到http.Server还有一个字段Handler也能定义申请解决办法，因为该字段的类型就是http.Handler，也就是说咱们能够本人定义一个构造（只有实现ServeHTTP办法），自定义申请匹配形式。

  下面提到的多个构造/接口关系如下图所示：

gin 概述

  gin是一款十分热门的的web框架，很多web服务都是基于他搭建的。gin为咱们提供了更加丰盛的路由匹配形式，还有middleware拦截器更是为咱们提供了极大便当。gin的应用非常简单，如下所示：

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    //注册路由
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "pong",
        })
    })
    r.Run()
}

  gin框架有三个十分重要的构造定义：1）gin.RouterGroup提供多个路由注册办法，这些办法对应着HTTP申请method，如gin.RouterGroup.GET只注册GET申请路由，gin.RouterGroup.Any注册的路由与申请method无关；2）gin.Engine就是gin框架实例，其继承了构造gin.RouterGroup，所以下面的事例程序能力通过”r.GET”注册路由。另外，gin框架底层其实还是基于http.Server创立的web服务，也就是HTTP申请的解析、解决流程、响应阶段仍然是http.Server实现的。那么，HTTP申请的解决gin框架是如何接管的呢？还记得http.Handler接口吗（只有一个办法ServeHTTP），Go语言HTTP申请处理器都必须实现接口http.Handler，所以只须要gin.Engine实现http.Handler接口就能够了。

type RouterGroup struct {
    //申请解决链（拦截器）
    Handlers HandlersChain
    //根本门路
    basePath string
    //engin实例
    engine   *Engine
}

//路由组
func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
    return &RouterGroup{
        Handlers: group.combineHandlers(handlers),
        basePath: group.calculateAbsolutePath(relativePath),
        engine:   group.engine,
    }
}

func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
    return group.handle(http.MethodPost, relativePath, handlers)
}


type Engine struct {
    RouterGroup
    //路由
    trees            methodTrees
}
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
}

  gin.Engine实现了办法ServeHTTP，所以能够间接替换Go语言HTTP申请解决阶段，实现自定义的路由匹配，参数解析，申请解决，返回响应后果等等。gin.Engine构造蕴含一个字段类型为methodTrees，注册的所有路由都存储在该字段，gin框架路由存储与匹配基于前缀树（Tire）实现，晋升路由匹配效率，有趣味的读者能够本人钻研下前缀树。

  基于gin框架注册路由时，申请解决办法只有一个输出参数，类型为gin.Context，该构造封装了原生的http.ResponseWriter以及http.Request，基于此定义了很多办法，如解析参数，返回响应后果：

//解析json申请，obj构造体指针类型变量
func (c *Context) BindJSON(obj interface{}) error 
//获取申请query参数
func (c *Context) Query(key string) string
//获取申请header
func (c *Context) GetHeader(key string) string

//响应后果增加header
func (c *Context) Header(key, value string)
//返回json后果，code为HTTP状态码，obj为返回构造变量
func (c *Context) JSON(code int, obj interface{})

  最初不得不提gin框架十分重要的概念，middleware拦截器。构想有这么一个需要，服务的局部接口须要校验登录态怎么办？将登录态逻辑写到每一个申请解决办法吗？老本貌似有点高。不晓得你有没有留神到，gin框架注册路由的第二个参数，是可变参数，也就是能够传递多个HandlerFunc（解决链），路由匹配胜利后遍历执行所有的HandlerFunc。middleware拦截器与此相似，gin.Engine.Use办法能够注册全局的拦截器，gin.RouterGroup.Group办法也能够注册路由组的拦截器，通过在蓝拦截器校验登录态老本更低（校验胜利，设置用户信息上下文，执行下一个拦截器；校验失败，间接返回），校验登录拦截器能够如下所示：

loginGroup := router.Group("/admin", middleware.AuthCheck())
//所有以/admin开始的申请都匹配到loginGroup组，并且执行AuthCheck办法

func AuthCheck() gin.HandlerFunc {
    return func(c *gin.Context) {
        if 失败 {
            // 返回未登录
            c.AbortWithStatusJSON(http.StatusOK, errorCode.UserNotLogin)
        }

        //执行下一个拦截器
        c.Next()
    }

}

//遍历执行下一个拦截器
func (c *Context) Next() {
    c.index++
    for c.index < int8(len(c.handlers)) {
        c.handlers[c.index](c)
        c.index++
    }
}

  gin.Context.Next办法用于执行下一个拦截器（也能够没有，以后拦截器执行结束后，主动执行下一个拦截器）；联合Next办法，咱们能够在同一个拦截器实现，既拦挡申请达到又拦挡申请返回（Next办法之后的逻辑，在申请返回时执行）。

  通过web服务会注册多个拦截器，包含trace用于全链路追踪，recover用于捕捉申请panic，accesslog用于记录拜访日志等等，而gin框架自身也提供了几个默认的拦截器能够应用，如gin.Logger()、gin.Recovery()。

如何记录access日志

  咱们写的服务不可能没有任何异样，而且日常工作中可能常常须要排查客户反馈问题，这时候你能失去的信息可能非常少，只有客户的手机号或者用户ID等，依据这些简略的信息如何去定位排查问题呢？第一步必定是要搞清楚，客户在什么时候出的什么错，也就是什么时候申请的什么接口，返回的什么数据。这些信息也能够去接入层如网关查问，不过网关可能不会记录用户ID（网关不会校验登录态），甚至没有申请参数与返回数据。

  这就须要咱们本身服务具备这样的性能了，记录申请拜访日志（包含用户信息，申请参数，申请接口，返回数据等等），当然日志记录与采集也是须要老本的，这就须要在问题排查与老本之间均衡抉择了。

  参考gin框架，咱们能够注册一个全局的拦截器accesslog用于记录拜访日志，gin框架自身也提供有默认的拦截器能够应用：

func LoggerWithConfig(conf LoggerConfig) HandlerFunc {

    return func(c *Context) {
        // Start timer
        start := time.Now()
        path := c.Request.URL.Path
        raw := c.Request.URL.RawQuery

        // Process request
        c.Next()

        // Log only when path is not being skipped
        if _, ok := skip[path]; !ok {
            param := LogFormatterParams{
                Request: c.Request,
                isTerm:  isTerm,
                Keys:    c.Keys,
            }

            // Stop timer
            param.TimeStamp = time.Now()
            param.Latency = param.TimeStamp.Sub(start)

            param.ClientIP = c.ClientIP()
            param.Method = c.Request.Method
            param.StatusCode = c.Writer.Status()
            param.ErrorMessage = c.Errors.ByType(ErrorTypePrivate).String()

            param.BodySize = c.Writer.Size()

            if raw != "" {
                path = path + "?" + raw
            }

            param.Path = path

            fmt.Fprint(out, formatter(param))
        }
    }
}

//[GIN] 2022/09/14 - 11:21:26 | 200 |      201.43µs |       127.0.0.1 | GET      "/ping"

  能够看到，默认日志拦截器记录了客户端IP，申请接口，耗时，响应状态码等信息。当然你本人实现时也能够增加其余额定信息，如用户信息。只不过在记录申请参数以及响应后果时，你会发现，申请参数Request.Body只能读取一次，拦截器读取了后续流程怎么办？响应数据压根获取不到！

  针对这两个问题，有一些办法能够解决，申请参数Request.Body只能读取一次，那就读取之后再将数据塞回去，那后续流程就能持续获取申请数据了。至于获取响应数据无奈获取的问题，能够封装并替换gin框架原生的ResponseWriter，在写响应数据的时候，先缓存到buffer，再调用原生ResponseWriter返回数据即可。这两个问题的解决方案如上面代码所示：

//body就是申请参数了，也不影响后续流程
var body []byte
if c.Request.Body != nil {
    body, _ = ioutil.ReadAll(c.Request.Body)
}
//将数据再塞回去
c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(body))

//封装gin.ResponseWriter
type bodyLogWriter struct {
    gin.ResponseWriter
    body *bytes.Buffer
}
//将响应数据同时缓存在buffer
func (w bodyLogWriter) Write(b []byte) (int, error) {
    if _, err := w.body.Write(b); err != nil {
        log.Printf("bodyLogWriter err:%v", err)
    }
    return w.ResponseWriter.Write(b)
}
//替换writer
blw := &bodyLogWriter{body: bytes.NewBuffer([]byte{}), ResponseWriter: c.Writer}
c.Writer = blw

总结

  本篇文章首先介绍了http.Server的次要流程，包含监听，解析申请，解决申请，响应数据等阶段，咱们也直到了Go语言HTTP申请处理器都必须实现接口http.Handler，通过实现该接口，咱们能够自定义申请匹配以及解决形式。另外，还解说了热门gin框架的根本应用，包含路由注册形式，middleware拦截器的概念以及原理，以及在此之上如何记录access日志。