Golang标准库探秘（二）：快速搭建HTTP服务器

jjvb3338 9年前

来自： http://www.infoq.com/cn/articles/golang-standard-library-part02

服务器阐述：

现在市面上有很多高并发服务器，Nginx就是一个领军人物，也是我们仰望的存在；Nginx+Lua这种组合也是高并发服务器的一个代表；PHP语言作为Nginx+FastCGI上一个优秀的解释语言也占据大半江山。而如今的Golang也作为高并发服务器语言横空出世，因其“语法简单、代码结构简明，维护成本还低，天生高并发”等特性而被广泛应用，尤其是各种云服务，还有Docker也是用Golang来做实现语言。

接着我们介绍下服务器编程模型，只从线程的角度，不谈并发模型。

从线程的角度，可以分为“单线程”，“多线程”2种。

单线程：

整个进程只有一个线程，因为只有一个线程的缘故，当请求来的时候只能一个个按照顺序处理，要想实现高性能只能用“non-blocking IO + IO multiplexing”组合 (非阻塞io + io复用)。 Nginx采用的就是多进程 + 单线程( 非阻塞io+io复用)模式。

多线程：

进程有多个线程，多个线程就不好控制，还带来一些问题：锁竞争，数据污染、山下文切换带来的开销，但是可以充分利用CPU。要实现高性能也是“non-blocking IO + IO multiplexing”组合。

所以，其实不管单线程还是多线程都是要用“non-blocking IO + IO multiplexing”组合的。还有一种用户级线程，整个线程的库都是自己维护，“创建，撤销，切换”，内核是不知道用户级线程存在的，缺点是阻塞时会阻塞整个进程。

其实想实现高并发服务器最好用单线程(不处理逻辑的情况下)，节省很多上下文切换开销(CPU分配时间片给任务，CPU加载上下文)，但一定要采用io上“非阻塞和异步”。因为多线程很难控制，锁，数据依赖，不同场景会让多线程变成串行，控制起来相当繁琐，牺牲很多并发性能(Golang采用的抢占式调度)，但正常情况下多线程还是挺不错的。下面我们说下Golang实现的高并发。

在Golang的调度器里用的也是“csp”并发模型，有3个重要的概念P、M、G。

P是Processor，G是Goroutine，M是Machine。

简述：M是执行G的机器线程，跟P绑定才可以执行，P存放G的队列。看到这里大家会问到刚刚不是说多线程切换上下文开销很大吗？其实每个M都有一个g0栈内存，用来执行运行时管理命令。调度时候M的g0会从每个G栈取出栈(现场)，调度之后再保存到G，这样不同的M就可以接着调度了。所有上下文都是自己在切换，省去了内核带来的开销，而且Golang会观察，长时间不调度的G会被其他G抢占(抢占调度其实就是一个标记)。

采用异步的方式运行G，这样就实现了并发(M可不止一个啊，感兴趣看下 Go并发实战。

看到上面估计大家可能稍微了解点Golang的优势了吧。不要担心GC问题，选择场景问题。

实战

现在我们进入实战部分，手把手教你实现CGI，FastCGI，HTTP服务器，主要是用Golang的HTTP包。TCP实战就不在这次说了，TCP其实是块难啃的骨头，简单的几乎话说不清楚，如果是简单写一个“hello world”的例子，让大家似懂非懂的，不如单独开篇讲解一下，从Tcp 到 Protobuf 再到RPC，然后写一个稍微复杂点的tcp服务器，我们也可以处理下“粘包，丢包”等问题(Protobuf解决或者做一个分包算法)，如果简单的demo可能会导致你丢失兴趣的。

首先了解什么是CGI？CGI和FastCGI的区别是什么？

CGI：全拼(Common Gateway Interface)是能让web服务器和CGI脚本共同处理客户的请求的协议。Web服务器把请求转成CGI脚本，CGI脚本执行回复Web服务器，Web服务回复给客户端。

CGI fork一个新的进程来执行，读取参数，处理数据，然后就结束生命期。

FastCGI采用tcp链接，不用fork新的进程，因为程序启动的时候就已经开启了，等待数据的到来，处理数据。

看出来差距在哪里了吧？就是CGI每次都要fork进程，这个开销很大的。（感兴趣的看下linux进程相关知识）。

现在我们来做我们的CGI服务器

CGI服务器

需要用到的包：

"net/http/cgi"  "net/http"

简单的2个包就可以实现CGI服务器了。“高秀敏：准备好了吗？希望别看到老头子他又错了的场景啊”。我们按照“代码->讲解”的流程，先运行在讲解。

package main;      import (      "net/http/cgi"         "fmt"         "net/http"      )            funcmain() {      http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request){            handler := new(cgi.Handler);      handler.Path = "/usr/local/go/bin/go";            script := "/Users/liujinlong/cgi-script" + r.URL.Path;      fmt.Println(handler.Path);      handler.Dir = "/Users/liujinlong/cgi-script";      args := []string{"run", script};      handler.Args = append(handler.Args, args...);      fmt.Println(handler.Args);            handler.ServeHTTP(w, r);         });      http.ListenAndServe(":8989",nil);      select {}//阻塞进程      }      test.go      package main            import(      "fmt"      )            funcinit() {      fmt.Print("Content-Type: text/plain;charset=utf-8\n\n");      }            funcmain() {      fmt.Println("hello!!!!")      }

看来我们成功了。来看下net/http/cgi的包。

先看host.go，这里有一个重要的结构Handler。

// Handler runs an executable in a subprocess with a CGI environment.      type Handler struct{         Path string // 执行程序      Root string // 处理url的根，为空的时候“/”      Dir string         //目录      Env        []string    // 环境变量      InheritEnv []string    //集成环境变量      Logger     *log.Logger// 日志      Args       []string    //参数      PathLocationHandlerhttp.Handler //http包的handler宿主      }        func(h *Handler) ServeHTTP(rwhttp.ResponseWriter, req *http.Request)

它也实现了ServeHttp，所有请求都会调用这个，这个后面分析HTTP源码的时候回详细讲解它是做什么的。Handler是在子程序中执行CGI脚本的。

funcRequest() (*http.Request, error)      funcServe(handler http.Handler)       …

先是将前端CGI请求转换成net包的HTTP请求，然后执行Handler，然后处理response。

FastCGI服务器

接下来是FastCGI服务器，

用到的包：

"net"      "net/http"      "net/http/fcgi"

上面已经讲过，它是TCP的方式实现的，需要借助其他服务器来做转发，这里我们只提供代码，demo的截图讲解TCP的时候在加上。

需要使用Nginx，我电脑上没有。各位自己测试一下

server {              listen 80;   server_name ****;              ...              location *... {                      include         fastcgi.conf;      fastcgi_pass    127.0.0.1:9001;              }              ...      }//…是省略，自己去写一个server。(具体谷歌)      package main            import (    "net"         "net/http"         "net/http/fcgi"      )            type FastCGIstruct{}            func(s *FastCGI) ServeHTTP(resphttp.ResponseWriter, req *http.Request) {      resp.Write([]byte("Hello, fastcgi"))      }            funcmain() {         listener, _ := net.Listen("tcp", "127.0.0.1:8989")   srv := new(FastCGI)        fcgi.Serve(listener, srv)      select {               }      }

HTTP服务器

接下来就是重点了，我们的HTTP服务器，这个大家都不陌生，HTTP是最常用的方式之一，通用性很强，跨团队协作上也比较受到推荐，排查问题也相对来说简单。

我们接下来以3种方式来展现Golang的HTTP服务器的简洁和强大。

写一个简单的HTTP服务器
写一个稍微复杂带路由的HTTP服务器
分析源码，然后实现一个自定义Handler的服务器

然后我们对照net/http包来进行源码分析，加强对http包的理解。

1、写一个简单的HTTP服务器：

package main;            import (      "net/http"      )            funchello(w http.ResponseWriter, req *http.Request) {      w.Write([]byte("Hello"))      }      funcsay(w http.ResponseWriter, req *http.Request) {      w.Write([]byte("Hello"))      }      funcmain() {      http.HandleFunc("/hello", hello);      http.Handle("/handle",http.HandlerFunc(say));      http.ListenAndServe(":8001", nil);      select{};//阻塞进程      }

是不是很简单，我用2种方式演示了这个例子，HandleFunc和Handle方式不同，却都能实现一个路由的监听，其实很简单，但是很多人看到这都会有疑惑，别着急，咱们源码分析的时候你会看到。

2、写一个稍微复杂带路由的HTTP服务器：

对着上面的例子想一个问题，我们在开发中会遇到很多问题，比如handle/res，handle/rsa…等等路由，这两个路由接受的参数都不一样，我们应该怎么写。我先来个图展示下运行结果。

是不是挺惊讶的，404了，路由没有匹配到。可是我们写handle这个路由了。

问题：

什么原因导致的路由失效
如何解决这种问题，做一个可以用Controller来控制的路由

问题1：

我们在源码阅读分析的时候会解决。

问题2：

我们可以设定一个控制器Handle，它有2个action，我们的执行handle/res对应的结果是调用Handle的控制器下的res方法。这样是不是很酷。

来我们先上代码：

静态目录：

css
js
image

静态目录很好实现，只要一个函数http.FileServer()，这个函数从文字上看就是文件服务器，他需要传递一个目录，我们常以http.Dir("Path")来传递。

其他目录大家自己实现下，我们来实现问题2，一个简单的路由。

我们来看下代码

package main;            import (      "net/http"         "strings"         "reflect"         "fmt"      )            funchello(w http.ResponseWriter, req *http.Request) {      w.Write([]byte("Hello"));      }                  type Handlers struct{            }            func(h *Handlers) ResAction(w http.ResponseWriter, req *http.Request)  {      fmt.Println("res");      w.Write([]byte("res"));      }      funcsay(w http.ResponseWriter, req *http.Request) {      pathInfo := strings.Trim(req.URL.Path, "/");         parts := strings.Split(pathInfo, "/");      varaction = "";      fmt.Println(strings.Join(parts,"|"));      if len(parts) >1 {            action = strings.Title(parts[1]) + "Action";         }      fmt.Println(action);         handle := &Handlers{};         controller := reflect.ValueOf(handle);         method := controller.MethodByName(action);         r := reflect.ValueOf(req);      wr := reflect.ValueOf(w);      method.Call([]reflect.Value{wr, r});      }      funcmain() {      http.HandleFunc("/hello", hello);      http.Handle("/handle/",http.HandlerFunc(say));      http.ListenAndServe(":8081", nil);      select{};//阻塞进程      }

上面代码就可以实现handle/res，handle/rsa等路由监听，把前缀相同的路由业务实现放在一个文件里，这样也可以解耦合，是不是清爽多了。其实我们可以在做的更加灵活些。在文章最后我们放出来一个流程图，按照流程图做你们就能写出一个简单的mvc路由框架。接下来看运行之后的结果。

如下图：

(点击放大图像)

3、分析源码，然后实现一个自定义Handler的服务器

现在我们利用这个例子来分析下http包的源码(只是服务器相关的，Request我们此期不讲，简单看看就行。)

其实使用Golang做web服务器的方式有很多，TCP也是一种，net包就可以实现，不过此期我们不讲，因为HTTP服务器如果不懂，TCP会让你更加不明白。

我们从入口开始，首先看main方法里的http.HandleFunc和http.Handle这个绑定路由的方法，上面一直没解释有啥区别。现在我们来看一下。

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

Handle 和HandleFunc都是注册路由，从上面也能看出来这两个函数都是绑定注册路由函数的。如何绑定的呢？我们来看下。

上面2个函数通过DefaultServeMux.handle，DefaultServeMux.handleFunc把pattern和HandleFunc绑定到ServeMux的Handle上。

为什么DefaultServeMux会把路由绑定到ServeMux上呢？

// DefaultServeMux is the default ServeMux used by Serve.      varDefaultServeMux = NewServeMux()

因为DefaultServeMux就是ServeMux的实例对象。导致我们就把路由和执行方法绑注册好了。不过大家请想下handle/res的问题？

从上面的分析我们要知道几个重要的概念。

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 object that calls f.      type HandlerFuncfunc(ResponseWriter, *Request)            // ServeHTTP calls f(w, r).      func(f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {         f(w, r)      }

上面的大概意思是，定义了一个函数适配器(可以理解成函数指针)HandleFunc，通过HandlerFunc(f)来进行适配。其实调用的实体是f本身。

package main      import "fmt"      type A func(int, int)      func(f A)Serve() {      fmt.Println("serve2")      }      funcserve(int,int) {      fmt.Println("serve1")      }      funcmain() {         a := A(serve)         a(1,2)//这行输出的结果是serve1      a.Serve()//这行输出的结果是serve2      }

上面结果是serve1，serve2

Golang的源码里用了很多HandleFunc这个适配器。

接下来我们看第二个，ServeMux结构，最终我们是绑定它，也是通过它来解析。

type ServeMuxstruct{         mu    sync.RWMutex//读写锁         m     map[string]muxEntry//路由map，pattern->HandleFunc         hosts bool//是否包含hosts              }            type muxEntrystruct{         explicit bool//是否精确匹配，这个在Golang实现里是ture         h        Handler //这个路由表达式对应哪个handler         pattern  string//路由      }

看到explicit的时候是不是就明白为啥handle/res不能用handle来监听了？原来如此。大致绑定流程大家看明白了吗？如果不理解可以回去再看一遍。

接下来我们来看实现“启动/监听/触发”服务器的代码。

http.ListenAndServe(":8081", nil);

上面这句就是，”:8081”是监听的端口，也是socket监听的端口，第二个参数就是我们的Handler，这里我们写nil。

funcListenAndServe(addr string, handler Handler) error {         server := &Server{Addr: addr, Handler: handler}      return server.ListenAndServe()      }

从这个代码看出来，Server这个结构很重要。我们来看看他是什么。

type Server struct {      Addr           string        // 监听的地址和端口          Handler        Handler       // 所有请求需要调用的Handler（      ReadTimeouttime.Duration // 读的最大Timeout时间      WriteTimeouttime.Duration // 写的最大Timeout时间      MaxHeaderBytesint           // 请求头的最大长度      TLSConfig      *tls.Config   // 配置TLS          ...   //结构太长我省略些，感兴趣大家自己看下      }

Server提供的方法有：

func(srv *Server) Serve(l net.Listener) error   //对某个端口进行监听，里面就是调用for进行accept的处理了      func(srv *Server) ListenAndServe() error  //开启http server服务      func(srv *Server) ListenAndServeTLS(certFile, keyFile string) error //开启https server服务

Server的ListenAndServe方法通过TCP的方式监听端口，然后调用Serve里的实现等待client来accept，然后开启一个协程来处理逻辑(go c.serve)。

它的格式

func(srv *Server) ListenAndServe() error

看到这里我们要了解几个重要的概念。

ResponseWriter：生成Response的接口

Handler：处理请求和生成返回的接口

ServeMux：路由，后面会说到ServeMux也是一种Handler

Conn : 网络连接

这几个概念看完之后我们下面要用。

type conn struct

这个结构是一个网络间接。我们暂时忽略。

这个c.serve里稍微有点复杂，它有关闭这次请求，读取数据的，刷新缓冲区的等实现。这里我们主要关注一个c.readRequest()，通过redRequest可以得到Response，就是输出给客户端数据的一个回复者。

它里面包含request。如果要看懂这里的实现就要搞懂三个接口。

ResponseWriter, Flusher, Hijacker        // ResponseWriter的作用是被Handler调用来组装返回的Response的      type ResponseWriter interface {          // 这个方法返回Response返回的Header供读写      Header() Header            // 这个方法写Response的Body      Write([]byte) (int, error)            // 这个方法根据HTTP State Code来写Response的Header            WriteHeader(int)      }            // Flusher的作用是被Handler调用来将写缓存中的数据推给客户端      type Flusher interface {      // 刷新缓冲区      Flush()      }            // Hijacker的作用是被Handler调用来关闭连接的      type Hijacker interface {      Hijack() (net.Conn, *bufio.ReadWriter, error)            }

而我们这里的w也就是ResponseWriter了。而调用了下面这句方法，就可以利用它的Write方法输出内容给客户端了。

serverHandler{c.server}.ServeHTTP(w, w.req)

这句就是触发路由绑定的方法了。要看这个触发器我们还要知道几个接口。

具体我们先看下如何实现这三个接口的，因为后面我们要看触发路由执行逻辑片段。实现这三个接口的结构是response

response      // response包含了所有server端的HTTP返回信息      type response struct {          conn          *conn         // 保存此次HTTP连接的信息      req           *Request // 对应请求信息          chunking      bool     // 是否使用chunk      wroteHeaderbool     // header是否已经执行过写操作      wroteContinuebool     // 100 Continue response was written          header        Header   // 返回的HTTP的Header          written       int64    // Body的字节数      contentLength int64    // Content长度          status        int      // HTTP状态      needSniffbool    //是否需要使用sniff。（当没有设置Content-Type的时候，开启sniff能根据HTTP body来确定Content-Type）      closeAfterReplybool      //是否保持长链接。如果客户端发送的请求中connection有keep-alive，这个字段就设置为false。      requestBodyLimitHitbool   //是否requestBody太大了（当requestBody太大的时候，response是会返回411状态的，并把连接关闭）      }

在response中是可以看到

func(w *response) Header() Header       func(w *response) WriteHeader(code int)       func(w *response) Write(data []byte) (n int, err error)       func(w *response) WriteString(data string) (n int, err error)       // either dataB or dataS is non-zero.      func(w *response) write(lenDataint, dataB []byte, dataS string) (n int, err error)       func(w *response) finishRequest()      func(w *response) Flush()       func(w *response) Hijack() (rwcnet.Conn, buf *bufio.ReadWriter, err error)

我简单罗列一些，从上面可以看出，response实现了这3个接口。

接下来我们请求真正的触发者也就是serverHandle要触发路由(hijacked finishRequest暂且不提)。先看一个接口。

Handler            type Handler interface {      ServeHTTP(ResponseWriter, *Request)  // 具体的逻辑函数      }

实现了handler接口，就意味着往server端添加了处理请求的逻辑函数。

serverHandle调用ServeHttp来选择触发的HandleFunc。这里面会做一个判断，如果你传递了Handler，就调用你自己的，如果没传递就用DefaultServeMux默认的。到这整体流程就结束了。

过程是：

DefaultServeMux.ServeHttp执行的简单流程.

h, _ := mux.Handler(r)
h.ServeHTTP(w, r) //执行ServeHttp函数

查找路由，mux.handler函数里又调用了另外一个函数mux.handler(r.Host, r.URL.Path)。

还记得我们的ServeMux里的hosts标记吗？这个函数里会进行判断。

// 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(), ""         }

上面就是匹配查找pattern和handler的流程了

我们来总结一下。

首先调用Http.HandleFunc

按顺序做了几件事：

调用了DefaultServerMux的HandleFunc
调用了DefaultServerMux的Handle
往DefaultServeMux的map[string]muxEntry中增加对应的handler和路由规则

别忘记DefaultServerMux是ServeMux的实例。其实都是围绕ServeMux，muxEntry2个结构进行操作绑定。

其次调用http.ListenAndServe(":12345", nil)

按顺序做了几件事情：

实例化Server
调用Server的ListenAndServe()
调用net.Listen("tcp", addr)监听端口，启动for循环，等待accept请求
对每个请求实例化一个Conn，并且开启一个goroutine处理请求。
如：go c.serve()
读取请求的内容w, err := c.readRequest()，也就是response的取值过程。
调用serverHandler的ServeHTTP，ServeHTTP里会判断Server的属性里的header是否为空，如果没有设置handler，handler就设置为DefaultServeMux，反之用自己的(我们后面会做一个利用自己的Handler写服务器)
调用DefaultServeMux的ServeHttp( 因为我们没有自己的Handler，所以走默认的)
通过request选择匹配的handler：

A request匹配handler的方式。Hosts+pattern或pattern或notFound

B 如果有路由满足，返回这个handler

C 如果没有路由满足，返回NotFoundHandler
根据返回的handler进入到这个handler的ServeHTTP

大概流程就是这个样子，其实在net.Listen("tcp", addr)里也做了很多事，我们下期说道TCP服务器的时候回顾一下他做了哪些。

通过上面的解释大致明白了我们绑定触发的都是DefaultServeMux的Handler。现在我们来实现一个自己的Handler，这也是做框架的第一步。我们先来敲代码。

package main;            import (      "fmt"         "net/http"         "time"      )            type customHandlerstruct{            }            func(cb *customHandler) ServeHTTP( w http.ResponseWriter, r *http.Request ) {      fmt.Println("customHandler!!");      w.Write([]byte("customHandler!!"));      }            funcmain() {      varserver *http.Server = &http.Server{      Addr:           ":8080",            Handler:        &customHandler{},      ReadTimeout:    10 * time.Second,      WriteTimeout:   10 * time.Second,      MaxHeaderBytes: 1 <<20,         }      server.ListenAndServe();      select {         }      }

是不是很酷，我们可以利用自己的handler做一个智能的路由出来。

不过还是建议使用国内Golang语言框架 beego ，已开源。一款非常不错的框架，谢大维护的很用心，绝对良心框架，而且文档支持，社区也很不错。

最后附上一张最早设计框架时候的一个流程图(3年前)。大家可以简单看看，当然也可以尝试的动动手。起码收获很多。

(点击放大图像)

[1]: http://item.jd.com/11573034.html

[2]: https://github.com/astaxie/beego

作者简介

刘金龙，艺名：金灶沐，go语言爱好者，2015年8月加入创业团队，负责各种“打杂”工作，之前在360电商购物小蜜java组担任java高级工程师职位，负责购物小蜜服务开发。14年开始用go语言做高并发服务并且尝试阅读go语言的源码来学习go语言的特性。

Golang标准库探秘（二）：快速搭建HTTP服务器

实战

CGI服务器

FastCGI服务器

HTTP服务器

作者简介

相关经验

目录