golang http server分析(一)

golang中使用的http协议版本是RFC2616

对于一个http服务来讲，需要兼容新旧版本的http协议，http1.0/2.0，以及https的支持，http的通信是建立在tcp连接基础上的通信。

现在协议有了，连接通信也有了，还剩一个问题就是如何处理client request请求，这个问题可以分为路由和具体逻辑实现，下面看看在golang中是如何解决这些问题的。

路由部分

在golang中有个Handler的概念，一个URL对应一个Handler，在Handler中处理request的具体逻辑，对应关系保存在一个map结构中

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry //key是URL匹配字符串，muxEntry是对应的处理handler
    hosts bool // 路由匹配时，是否包含host
}

Handler分为一般类型Handler和特殊类型Handler，特殊类型Handler是指包含特定功能处理的Handler，

比如redirectHandler用来处理302跳转、NotFoundHandler用来处理404请求等。

Handler定义如下:

// Handler类型定义
type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

//一般Handler是一函数体，实现了Handler接口，通过该函数可以将一个自定义函数转换为Handler
type HandlerFunc func(ResponseWriter, *Request)
// 绑定对象就是自定义函数本身，通过在ServerHTTP中调用函数本身，实现了钩子功能。
// 也就是说，当程序调用Handler.ServerHTTP()方法的时候，实际上是调用的跟Handler绑定的自定义函数
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    // 调用绑定对象函数
    f(w, r)
}

明确了Handler的定义，接下来就要看看如何注册Handler了，Handler的注册是通过HandleFunc()函数实现的，在HandleFunc中调用ServerMux的HandleFunc()

方法将一个自定义的方法转换为一个一般Handler，最后再调用Server.Mux的handle()方法，完成URL与Handler的绑定，下面详细看看handle()的实现，

func (mux *ServeMux) Handle(pattern string, handler Handler) {
    // 加一个写锁
    mux.mu.Lock()
    defer mux.mu.Unlock()
    // url匹配字符串不能为空
    if pattern == "" {
        panic("http: invalid pattern " + pattern)
    }
    // handler不能为空
    if handler == nil {
        panic("http: nil handler")
    }
    // 对应关系没有被注册过
    if mux.m[pattern].explicit {
        panic("http: multiple registrations for " + pattern)
    }

    // 添加到map
    mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}

    // 判断是否以hosts开头的url
    if pattern[0] != '/' {
        mux.hosts = true
    }

    // 如果URL以字符/结尾，则多注册注册一个redirectHandler，访问/tree时重定向到/tree/
    n := len(pattern)
    if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {
        path := pattern
        if pattern[0] != '/' {
            path = pattern[strings.Index(pattern, "/"):]
        }
        url := &url.URL{Path: path}
        mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern}
    }
}

redirectHandle定义:

// redirectHandler是一个结构体，实现了Handler接口
type redirectHandler struct {
    url  string
    code int
}

func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request) {
    // 重定向，设置location，status
    Redirect(w, r, rh.url, rh.code)
}

通信部分

http请求过程实质上是一个tcp连接通信，具体通过socket接口编码实现，socket部分另起文章详细说明，这里只做简单介绍，socket操作流程如下：

在golang中的使用，通过listenAndServer()函数一步完成

func (srv *Server) ListenAndServe() error {
    addr := srv.Addr
    if addr == "" {
        addr = ":http"
    }
    // 创建socket文件描述符，绑定ip:port，改变socket状态为监听状态
    ln, err := net.Listen("tcp", addr)
    if err != nil {
        return err
    }
    // 启动服务，处理连接请求,tcpKeepAliveListener是一个长连接
     return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

在svr.Server()函数中会循环Accept() tcp 连接请求，每当读取到一个tcp conn就启动一个goroutine去处理连接信息，

对于http服务来讲，在goroutine中完成了http request的处理流程如下

readRequest()：从tcp conn中读取一个http request，完成了http请求的heand以及body的解析依据http协议对请求信息的校验，详细过程如下

1. 设置tcp conn读取数据超时时间，设置请求头数据大小限制，过滤http1.0 post请求后多添加的空格

2. 读取请求信息并格式化

3. 校验请求头信息是否合法

4. 封装成一个response返回，下面详细介绍

获取到请求信息，接下来就该调用URL对应的具体逻辑了，通过Handler.ServerHTTP()完成了对Handler的调用，主要操作如下：

1. 根据请求信息host,path在serverMux中查找对应的Handler

2. 如果找不到对应Handler，会返回一个NotFoundHandler

3. 调用handler.ServerHttp()

finishRequest()：关闭http request请求处理，主要操作如下

1. 刷掉bufio.writer里的数据

2. 关闭chunkWriter()写入流

3. 刷掉conn缓冲流里的数据

4. 关闭tcp连接

接下来介绍下http是如何完成数据的读写的，对数据的读写操作本质上都是在对socket fd进行操作，通过connReader结构体包装好了对net.Con的操作，

这样就可以通过对connReader的操作最终作用到net.Con，而在net.Con中完成了fd的读写操作，golang中io部分很多地方都用来这种思想，通过包装器包装好需要操作的对象，在调用过程中只需要操作包装器就可以了。

下面看看golang中是如何实现的，拿解析请求函数举例来看看读取数据的过程，先看看函数定义：

func readRequest(b *bufio.Reader, deleteHostHeader bool) (req *Request, err error) {
    tp := newTextprotoReader(b)
    req = new(Request)

    var s string
    if s, err = tp.ReadLine(); err != nil {
        return nil, err
    }
        ...
}

没错请求的处理是通过bufio.Reader.ReadLine()一行一行的从tcp conn中读取出来的，在看看这个函数是怎么被调用的

c.r = &connReader{r: c.rwc} // connReader就是上面提到的tcp连接包装器
c.bufr = newBufioReader(c.r) // 定义一个读缓存io流
c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10) //定义一个写缓存io流
// 调用解析请求函数
req, err := readRequest(c.bufr, keepHostHeader)

接下来看看写操作过程，http中通过response对象将数据写入tcp连接的，并对写入流做了优化操作，对response的使用如下

w = &response{
    conn:          c, //当前tcp conn
    req:           req, // 当前请求对应的request对象
    reqBody:       req.Body,
    handlerHeader: make(Header), //初始化header头存储块
    contentLength: -1, // 内容长度
}
w.cw.res = w // 第二层缓冲流，通过chunkWriter将内容写入conn缓冲区
w.w = newBufioWriterSize(&w.cw, bufferBeforeChunkingSize) // 第一层缓冲流，通过buio writer将数据写入chunkWriter

封装好response对象后，通过serverHandler{c.server}.ServeHTTP(w, w.req)方法将对象传入Handler中，最终装换为一个http.ResponseWriter对象执行，本质上

都是io.Writer对象

总结：

这篇文字主要介绍了http包中的路由和通信部分，由于通信部分涉及到一些socket通信的问题，只是简单的提了一下，后面会专门针对socket总结一篇文章，http包中

Request和Response没有详细展开介绍，基本上对http协议规范的实现都在这两个里面体现，还有前文提到的http服务需要支持的一些特性也都没有提及到，后面陆续来吧。