golong http server

func main(){
http.HandleFunc("/",test)
http.ListenAndServe(":8080",nil)
}
func test(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("hello world"))
}

上面go实现的一个最简单的一个http服务器。

首先是http.HandleFunc,由下面代码可以看到HandleFunc其实就是调了DefaultServeMux.HandleFunc，其中DefaultServeMux是http默认的ServeMux，在ServeMux定义出可以看到关于这个结构作用的注释。

ServeMux通过注册的pattern匹配每一个进来的请求，并且调用跟URL最匹配的pattern的Handler。每一个ServeMux都维护着自己的一份匹配规则和Handler，其中关于Handler，为感觉这个东西比较绕，需要具体梳理。

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
   DefaultServeMux.HandleFunc(pattern, handler)
}
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux
type ServeMux struct {
   mu    sync.RWMutex
   m     map[string]muxEntry
   hosts bool // whether any patterns contain hostnames
}
type muxEntry struct {
   h       Handler
   pattern string
}

由下面代码可以看到，Handler是一个接口，而HandlerFunc是一个实现了Handler接口的func类型，上面代码可以看到，当调用http.HandleFunc时，其实就是调了DefaultServeMux.HandleFunc。然后调DefaultServeMux.Handle，并且在调用时将handler转成HandlerFunc类型。总而言之，http.HandleFunc就是DefaultServeMux注册一个匹配规则和其回调函数。如果是自定义的ServeMux，直接掉ServeMux.HandleFunc来注册。

type Handler interface {
   ServeHTTP(ResponseWriter, *Request)
}
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
   f(w, r)
}
unc (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
   mux.Handle(pattern, HandlerFunc(handler))
}
func (mux *ServeMux) Handle(pattern string, handler Handler) {
   mux.mu.Lock()
   defer mux.mu.Unlock()

   if pattern == "" {
      panic("http: invalid pattern")
   }
   if handler == nil {
      panic("http: nil handler")
   }
   if _, exist := mux.m[pattern]; exist {
      panic("http: multiple registrations for " + pattern)
   }

   if mux.m == nil {
      mux.m = make(map[string]muxEntry)
   }
   mux.m[pattern] = muxEntry{h: handler, pattern: pattern}

   if pattern[0] != '/' {
      mux.hosts = true
   }
}

再看第二行代码http.ListenAndServe。

func ListenAndServe(addr string, handler Handler) error {
   server := &Server{Addr: addr, Handler: handler}
   return server.ListenAndServe()
}
func (srv *Server) ListenAndServe() error {
   addr := srv.Addr
   if addr == "" {
      addr = ":http"
   }
   ln, err := net.Listen("tcp", addr)
   if err != nil {
      return err
   }
   return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

首先是调用net包的Listen 方法来监听地址端口，然后调用Server.Serve 方法。Serve方法中主要l.Accept()和go c.serve(ctx),其中l.Accept()中默认设置keepalive:true，SetKeepAlivePeriod为3分钟。

c.serve()方法的功能从注释上看只有一句话Serve a new connection.具体处理逻辑可以看方法中注释// HTTP/1.x from here on.后面的内容。c.serve()中大概逻辑是一个for循环，循环从conn中读取request并处理request。具体代码一个是w, err := c.readRequest(ctx)和serverHandler{c.server}.ServeHTTP(w, w.req)。serverHandler.ServeHTTP()中的逻辑大概是先解析出request的host和path，然后根据mux保存的pattern来匹配并处理。具体的match逻辑是先根据mux保存的map，进行完全比配，然后再通过前缀匹配，哪个匹配到的pattern长选哪个。（内置的路由功能确实有点弱）。

func (srv *Server) Serve(l net.Listener) error {
   defer l.Close()
   if fn := testHookServerServe; fn != nil {
      fn(srv, l)
   }
   var tempDelay time.Duration // how long to sleep on accept failure

   if err := srv.setupHTTP2_Serve(); err != nil {
      return err
   }

   srv.trackListener(l, true)
   defer srv.trackListener(l, false)

   baseCtx := context.Background() // base is always background, per Issue 16220
   ctx := context.WithValue(baseCtx, ServerContextKey, srv)
   for {
      rw, e := l.Accept()
      if e != nil {
             //errorHandle
      }
      tempDelay = 0
      c := srv.newConn(rw)
      c.setState(c.rwc, StateNew) // before Serve can return
      go c.serve(ctx)
   }

小结：
1、接收请求后调用Handler接口的ServeHTTP方法，如果ListenAndServe(addr string, handler Handler)的第二个参数为nil，处理请求用的就是DefaultServeMux,这个逻辑在serverHandler{c.server}.ServeHTTP(w, w.req)这行代码中实现。这行代码之前的逻辑都是一样的，但是后面的处理就取决于参数handler的ServeHTTP 方法。
2、每一个连接起一个协程处理，之前理解的都是每一个请求起一个协程处理。
3、默认路由功能比较简(la)单(ji)
4、http服务连接默认keepalive