Go对webserver的编写提供了很好的支持，标准库中提供了net/http包来方便编写server。很多教程和书籍在讲到用Go编写webserver时都会直接教新手用http包写一个最简单的hello worldserver，样例几乎相同都会像这样：

// 这就是用Go实现的一个最简短的hello worldserver.

package main

import "net/http"

func main() {

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

		w.Write([]byte(`hello world`))

	})

	http.ListenAndServe(":3000", nil) // <-今天讲的就是这个ListenAndServe是怎样工作的

}

能够看到。代码真的很简短，仅仅须要几行。我们今天要分析的是http.ListenAndServe()，看看这里面究竟都做了些什么。

首先，http.ListenAndServe用到的全部依赖都在Go源代码中的/src/pkg/net/http/server.go文件里，打开它会发现这页代码很长，有2000+行，我们Ctrl+F直接找我们感兴趣的部分。发如今1770行左右的部分找到了http.ListenAndServe的定义：

func ListenAndServe(addr string, handler Handler) error {

	// 创建一个Server结构体，调用该结构体的ListenAndServer方法然后返回

	server := &Server{Addr: addr, Handler: handler}

	return server.ListenAndServe()

}

从这个函数中就能够看出，调用http.ListenAndServe之后真正起作用的是Server结构体LisntenAndServe方法。给http.ListenAndServe传递的參数仅仅是用来创建一个Server结构体实例，Server结构体的定义例如以下：

type Server struct {

	Addr           string        // server的IP地址和port信息

	Handler        Handler       // 请求处理函数的路由复用器

	ReadTimeout    time.Duration

	WriteTimeout   time.Duration

	MaxHeaderBytes int

	TLSConfig      *tls.Config

	TLSNextProto map[string]func(*Server, *tls.Conn, Handler)

	ConnState func(net.Conn, ConnState)

	ErrorLog *log.Logger

	disableKeepAlives int32

}

假设我们不传详细的參数给http.ListenAndServe，那么它会自己主动以":http"(等价于":80")和DefaulServeMux作为參数来创建Server结构体实例。



接下来继续看看Server.ListenAndServe里面都做了些什么，1675行左右能够找到定义：

func (srv *Server) ListenAndServe() error {

	addr := srv.Addr

	if addr == "" {

		addr = ":http"  // 假设不指定server地址信息。默认以":http"作为地址信息

	}

	ln, err := net.Listen("tcp", addr)    // 这里创建了一个TCP Listener，之后用于接收client的连接请求

	if err != nil {

		return err

	}

	return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})  // 调用Server.Serve()函数并返回

}

能够看到。Server.ListenAndServe中创建了一个serverListener。然后在返回时把它传给了Server.Serve()方法并调用Server.Serve()。

继续分析Server.Serve，定义的位置在1690行左右：

func (srv *Server) Serve(l net.Listener) error {

	defer l.Close()

	var tempDelay time.Duration

	// 这个循环就是server的主循环了，通过传进来的listener接收来自client的请求并建立连接，

	// 然后为每个连接创建routine运行c.serve()。这个c.serve就是详细的服务处理了

	for {

		rw, e := l.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, err := srv.newConn(rw)

		if err != nil {

			continue

		}

		c.setState(c.rwc, StateNew) // before Serve can return

		go c.serve() // <-这里为每个建立的连接创建routine之后进行服务

	}

}

我们能够接着看看这个conn.serve()里面是怎么进行服务的。代码在1090行附近，仅仅看当中的主要部分：

func (c *conn) serve() {

	origConn := c.rwc // copy it before it's set nil on Close or Hijack

	// 这里做了一些延迟释放和TLS相关的处理...

	// 前面的部分都能够忽略，这里才是基本的循环

	for {

		w, err := c.readRequest()  // 读取client的请求

		// ...

		serverHandler{c.server}.ServeHTTP(w, w.req) //这里对请求进行处理

		if c.hijacked() {

			return

		}

		w.finishRequest()

		if w.closeAfterReply {

			if w.requestBodyLimitHit {

				c.closeWriteAndWait()

			}

			break

		}

		c.setState(c.rwc, StateIdle)

	}

}

经过一路的分析，http.ListenAndServe工作的流程就几乎相同明晰了，我们能够总结成一张流程图：

假设转载请注明出处：http://blog.csdn.net/gophers