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