golang的http分析

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

type ResponseWriter interface {
}

func ListenAndServe(addr string, handler Handler)

func Handle(pattern string, handler Handler)

type ImpHandler struct {}
 
func (h ImpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {  // 实现方法
    w.Write([]byte("haha"))
}
 
func main() {
    http.Handle("/", ImpHandler{})
    http.ListenAndServe(":12345", nil )
}

func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    hosts bool // whether any patterns contain hostnames
}
 
type muxEntry struct {
    explicit bool
    h        Handler
    pattern  string
}

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)})
}

// Multiple goroutines may invoke methods on a Listener simultaneously.
type Listener interface {
    // Accept waits for and returns the next connection to the listener.
    Accept() (Conn, error)
 
    // Close closes the listener.
    // Any blocked Accept operations will be unblocked and return errors.
    Close() error
 
    // Addr returns the listener‘s network address.
    Addr() Addr
}
 
// 这里实现得比较好，覆盖了一个Accept方法，在其中加入了keepAlived的选项。其他两个方法仍旧使用原listener的
type tcpKeepAliveListener struct {
    *net.TCPListener             // 外层可直接调它的方法不需要指定成员
}
 
func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
    tc, err := ln.AcceptTCP()
    if err != nil {
        return
    }
    tc.SetKeepAlive(true)
    tc.SetKeepAlivePeriod(3 * time.Minute)
    return tc, nil
}

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
    }
 
  ////////////////skip
    for {
        rw, e := l.Accept()               // 取出一个连接，对应accept
        if e != nil {
            if ne, ok := e.(net.Error); ok && ne.Temporary() {
                if tempDelay == 0 {
                    tempDelay = 5 * time.Millisecond
                } else {
                    tempDelay *= 2
                }
                if max := 1 * time.Second; tempDelay > max {
                    tempDelay = max
                }
                srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
                time.Sleep(tempDelay)
                continue
            }
            return e
        }
        tempDelay = 0
        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew) // before Serve can return
        go c.serve(ctx)
    }
}

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

// serverHandler delegates to either the server‘s Handler or
// DefaultServeMux and also handles "OPTIONS *" requests.
type serverHandler struct {
    srv *Server
}
 
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    if req.RequestURI == "*" && req.Method == "OPTIONS" {
        handler = globalOptionsHandler{}
    }
    handler.ServeHTTP(rw, req)
}
 
// 最终回到最开始注册Handle的地方，进行ServeHTTP的调用     
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
          if r.RequestURI == "*" {
                  if r.ProtoAtLeast(1, 1) {
                          w.Header().Set("Connection", "close")
                  }
                  w.WriteHeader(StatusBadRequest)
                  return
          }
          h, _ := mux.Handler(r)
          h.ServeHTTP(w, r)
}

func main() {
    fmt.Println("Hello.")
    http.HandleFunc("/", func (w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("haha2"))
    })
 
    http.ListenAndServe(":12346", nil )
}

// HandleFunc registers the handler function for the given pattern.
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    mux.Handle(pattern, HandlerFunc(handler))
}
 
// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

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

func NewServeMux() *ServeMux { return new(ServeMux) }

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    if req.RequestURI == "*" && req.Method == "OPTIONS" {
        handler = globalOptionsHandler{}
    }
    handler.ServeHTTP(rw, req)
}