- 当前位置：首页 >系统运维 >Go语言HTTP Server源码分析
Go语言HTTP Server源码分析
发布时间：2025-11-05 12:19:55 来源：创站工坊 作者：IT科技类资讯
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) }
你以为这样就结束了吗，不才刚刚开始。语言源码
源码分析
①路由注册
http中的分析HandleFunc方法,主要用来注册路由
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, were 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) }这里就是之前提到的匹配路由的b2b信息网具体代码
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接口是一个重要枢纽。
简单梳理下整个请求响应过程，如下图
- 环境:Ubuntu8.04 1.安装build工具 sudo aptitude install build-essential linux-headers-$(uname -r) 2.安装readline zlib libncurses5 apt-get install zlib1g-dev apt-get install libreadline5 libreadline5-dev apt-get install libncurses5 libncurses5-dev 3.安装ruby ruby的源代码下载： http://www.ruby-lang.org/en/downloads/ wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p114.tar.gz tar xvfz ruby-1.8.6-p114.tar.gz cd ruby-1.8.6-p114 ./configure --prefix=/usr/local/ruby sudo make sudo make install 安装好以后，加入/usr/local/ruby/bin到操作系统的PATH环境变量中 编辑/etc/environment gedit /etc/environment 在最后面加入： PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/ bin:/sbin:/bin:/usr/games:/usr/local/ruby/bin 执行命令,使环境变量修改生效： source /etc/environment 4.安装gem wget http://rubyforge.org/frs/download.php/29548/rubygems-1.0.1.tgz tar xzvf rubygems-1.0.1.tgz cd rubygems-1.0.1 sudo ruby setup.rb 验证gem是否安装成功并升级 sudo gem update --system 5.安装rails sudo gem install rails --include-dependencies 安装好rails以后，验证是否安装成功,可以执行： rails –v 确认一下rails的版本。 //========================================= 其实openssl-ruby是ruby的扩展（extension），它不是像其他纯ruby代码一样，可以用gem来安装。一般情况下需要编译才行。 在linux系统下，这是经常碰到的问题，所以必须记住。 对于openssl-ruby的编译。 首先 cd ruby-source/ext/openssl ruby extconf.rb make make install 进行上面的操作需要包：libssl-dev //===================================================== gem mysql 的时候都要安装下面的包 sudo apt-get install libmysqlclient15-dev 也就是说 要编译安装公司的工具包需要操作如何： 1.安装build工具 sudo aptitude install build-essential linux-headers-$(uname -r) 2.安装readline zlib libncurses5 apt-get install zlib1g-dev apt-get install libreadline5 libreadline5-dev apt-get install libncurses5 libncurses5-dev 3.安装 libssl-dev apt-get install libssl-dev 4安装 mysql 编译包 sudo apt-get install libmysqlclient15-dev
- 四个案例看懂 MySQL 事务隔离级别
- 2021年中国数据库行业研究报告
- Linux U盘分区与格式化和制作Linux文件系统
- 华为荣耀3Outdoor——探索极限，尽显荣耀（适合户外探险的智能手机，华为荣耀3Outdoor值得拥有）
- 沉默的Linux网管利器NetworkManager
- SELinux服务器不关闭配置 samba的方法
- 新型 macOS 恶意软件 ShadowVault 曝光，专门窃取用户敏感信息
- MIUI87.5.11（个性化定制，让你的手机与众不同）
- DevSecOps：在速度和安全性之间取得平衡
随便看看
服务器租用亿华云IT技术网香港云服务器源码下载企商汇益华科技源码库IT资讯网亿华云多维IT资讯亿华智慧云益强智囊团编程之道亿华云计算汇智坊益华科技益华科技智能时代码上建站益强智未来益强科技IT资讯网亿华灵动益强编程堂益强资讯优选益华IT技术论坛思维库极客编程云智核益强编程舍亿华科技益强科技码力社科技前瞻运维纵横亿华智造全栈开发益强数据堂益强前沿资讯技术快报
- Copyright © 2025 Powered by Go语言HTTP Server源码分析,创站工坊 滇ICP备2023006006号-44sitemap