这期内容当中小编将会给大家带来有关怎么进行Go语言HTTP Server源码分析，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

成都创新互联是专业的富阳网站建设公司，富阳接单;提供网站设计制作、成都网站制作,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行富阳网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

Go语言中HTTP Server:

HTTP  server，顾名思义，支持http协议的服务器，HTTP是一个简单的请求-响应协议，通常运行在TCP之上。通过客户端发送请求给服务器得到对应的响应。

HTTP服务简单实现

package main  import (     "fmt"     "net/http" )  //③处理请求，返回结果 func Hello(w http.ResponseWriter, r *http.Request) {     fmt.Fprintln(w, "hello world") }  func main() {     //①路由注册     http.HandleFunc("/", Hello)      //②服务监听     http.ListenAndServe(":8080", nil) }

你以为这样就结束了吗，不才刚刚开始。

源码分析

①路由注册

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {     DefaultServeMux.HandleFunc(pattern, handler) }

DefaultServeMux是什么?

DefaultServeMux是ServeMux的一个实例。

ServeMux又是什么?

// DefaultServeMux is the default ServeMux used by Serve. var DefaultServeMux = &defaultServeMux  var defaultServeMux ServeMux  type ServeMux struct {     mu    sync.RWMutex     m     map[string]muxEntry     hosts bool  }  type muxEntry struct {     explicit bool     h        Handler     pattern  string }

ServeMux主要通过map[string]muxEntry，来存储了具体的url模式和handler(此handler是实现Handler接口的类型)。通过实现Handler的ServeHTTP方法，来匹配路由(这一点下面源码会讲到)

很多地方都涉及到了Handler,那么Handler是什么?

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

此接口可以算是HTTP Server一个枢纽

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {     mux.Handle(pattern, HandlerFunc(handler)) }  type HandlerFunc func(ResponseWriter, *Request)  func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {     f(w, r) }

从代码中可以看出HandlerFunc是一个函数类型，并实现了Handler接口。当通过调用HandleFunc()，把Hello强转为HandlerFunc类型时，就意味着  Hello函数也实现ServeHTTP方法。

ServeMux的Handle方法:

func (mux *ServeMux) Handle(pattern string, handler Handler) {     mux.mu.Lock()     defer mux.mu.Unlock()      if pattern == "" {         panic("http: invalid pattern " + pattern)     }     if handler == nil {         panic("http: nil handler")     }     if mux.m[pattern].explicit {         panic("http: multiple registrations for " + pattern)     }      if mux.m == nil {         mux.m = make(map[string]muxEntry)     }     //把handler和pattern模式绑定到     //map[string]muxEntry的map上     mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}      if pattern[0] != '/' {         mux.hosts = true     }    //这里是绑定静态目录，不作为本片重点。     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}     } }

上面的流程就完成了路由注册。

②服务监听

type Server struct { 
    Addr         string         
    Handler      Handler        
    ReadTimeout  time.Duration  
    WriteTimeout time.Duration  
    TLSConfig    *tls.Config    
    MaxHeaderBytes int  
    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)  
    ConnState func(net.Conn, ConnState) 
    ErrorLog *log.Logger 
    disableKeepAlives int32        nextProtoOnce     sync.Once  
    nextProtoErr      error      
}  
func ListenAndServe(addr string, handler Handler) error { 
    server := &Server{Addr: addr, Handler: handler} 
    return server.ListenAndServe() 
}  
//初始化监听地址Addr，同时调用Listen方法设置监听。 
//***将监听的TCP对象传入Serve方法： 
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)}) 
    } 

Serve(l net.Listener)为每个请求开启goroutine的设计，保证了go的高并发。

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)     ctx = context.WithValue(ctx, LocalAddrContextKey, l.Addr())     //开启循环进行监听     for {        //通过Listener的Accept方法用来获取连接数据         rw, e := l.Accept()         if e != nil {             select {             case <-srv.getDoneChan():                 return ErrServerClosed             default:             }             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         //通过获得的连接数据，创建newConn连接对象         c := srv.newConn(rw)                 c.setState(c.rwc, StateNew) // before Serve can return        //开启goroutine发送连接请求         go c.serve(ctx)     } }

serve()为核心,读取对应的连接数据进行分配

func (c *conn) serve(ctx context.Context) {     c.remoteAddr = c.rwc.RemoteAddr().String()         //连接关闭相关的处理     defer func() {         if err := recover(); err != nil && err != ErrAbortHandler {             const size = 64 << 10             buf := make([]byte, size)             buf = buf[:runtime.Stack(buf, false)]             c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)         }         if !c.hijacked() {             c.close()             c.setState(c.rwc, StateClosed)         }     }()      .....      ctx, cancelCtx := context.WithCancel(ctx)     c.cancelCtx = cancelCtx     defer cancelCtx()      c.r = &connReader{conn: c}     c.bufr = newBufioReader(c.r)     c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)      for {         //读取客户端的请求         w, err := c.readRequest(ctx)         if c.r.remain != c.server.initialReadLimitSize() {             // If we read any bytes off the wire, we're active.             c.setState(c.rwc, StateActive)         }                 .................         //处理网络数据的状态         // Expect 100 Continue support         req := w.req         if req.expectsContinue() {             if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {                 // Wrap the Body reader with one that replies on the connection                 req.Body = &expectContinueReader{readCloser: req.Body, resp: w}             }         } else if req.Header.get("Expect") != "" {             w.sendExpectationFailed()             return         }          c.curReq.Store(w)          if requestBodyRemains(req.Body) {             registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)         } else {             if w.conn.bufr.Buffered() > 0 {                 w.conn.r.closeNotifyFromPipelinedRequest()             }             w.conn.r.startBackgroundRead()         }          //调用serverHandler{c.server}.ServeHTTP(w, w.req)         //方法处理请求         serverHandler{c.server}.ServeHTTP(w, w.req)         w.cancelCtx()         if c.hijacked() {             return         }         w.finishRequest()         if !w.shouldReuseConnection() {             if w.requestBodyLimitHit || w.closedRequestBodyEarly() {                 c.closeWriteAndWait()             }             return         }         c.setState(c.rwc, StateIdle)         c.curReq.Store((*response)(nil))          if !w.conn.server.doKeepAlives() {             return         }          if d := c.server.idleTimeout(); d != 0 {             c.rwc.SetReadDeadline(time.Now().Add(d))             if _, err := c.bufr.Peek(4); err != nil {                 return             }         }         c.rwc.SetReadDeadline(time.Time{})     } }

③处理请求，返回结果

serverHandler  主要初始化路由多路复用器。如果server对象没有指定Handler，则使用默认的DefaultServeMux作为路由多路复用器。并调用初始化Handler的ServeHTTP方法。

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

这里就是之前提到的匹配路由的具体代码

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 
    } 
    //匹配注册到路由上的handler函数 
    h, _ := mux.Handler(r) 
    //调用handler函数的ServeHTTP方法 
    //即Hello函数，然后把数据写到http.ResponseWriter 
    //对象中返回给客户端。 
    h.ServeHTTP(w, r) 
}
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) { 
    if r.Method != "CONNECT" { 
        if p := cleanPath(r.URL.Path); p != r.URL.Path { 
            _, pattern = mux.handler(r.Host, p) 
            url := *r.URL 
            url.Path = p 
            return RedirectHandler(url.String(), StatusMovedPermanently), pattern 
        } 
    } 
    return mux.handler(r.Host, r.URL.Path) 
}  
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) { 
    mux.mu.RLock() 
    defer mux.mu.RUnlock() 
 
    // Host-specific pattern takes precedence over generic ones 
    if mux.hosts { 
        //如 127.0.0.1/hello 
        h, pattern = mux.match(host + path) 
    } 
    if h == nil { 
        // 如  /hello 
        h, pattern = mux.match(path) 
    } 
    if h == nil { 
        h, pattern = NotFoundHandler(), "" 
    } 
    return 
}  
func (mux *ServeMux) match(path string) (h Handler, pattern string) { 
    var n = 0 
    for k, v := range mux.m { 
        if !pathMatch(k, path) { 
            continue 
        } 
      //通过迭代m寻找出注册路由的patten模式 
      //与实际url匹配的handler函数并返回。 
        if h == nil || len(k) > n { 
            n = len(k) 
            h = v.h 
            pattern = v.pattern 
        } 
    } 
    return 
} 
func pathMatch(pattern, path string) bool { 
    if len(pattern) == 0 { 
        // should not happen 
        return false 
    } 
    n := len(pattern) 
        //如果注册模式与请求uri一样返回true，否则false 
    if pattern[n-1] != '/' { 
        return pattern == path 
    } 
        //静态文件匹配 
    return len(path) >= n && path[0:n] == pattern 
} 

将数据写给客户端

//主要代码，通过层层封装才走到这一步  func (w checkConnErrorWriter) Write(p []byte) (n int, err error) {     n, err = w.c.rwc.Write(p)     if err != nil && w.c.werr == nil {         w.c.werr = err         w.c.cancelCtx()     }     return }

serverHandler{c.server}.ServeHTTP(w, w.req)当请求结束后，就开始执行连接断开的相关逻辑。

总结

Go语言通过一个ServeMux实现了的路由多路复用器来管理路由。同时提供一个Handler接口提供ServeHTTP方法，实现handler接口的函数，可以处理实际request并返回response。

ServeMux和handler函数的连接桥梁就是Handler接口。ServeMux的ServeHTTP方法实现了寻找注册路由的handler的函数，并调用该handler的ServeHTTP方法。

所以说Handler接口是一个重要枢纽。

简单梳理下整个请求响应过程，如下图

上述就是小编为大家分享的怎么进行Go语言HTTP Server源码分析了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联行业资讯频道。