Update zh/03.3.md

zh/03.3.md

@@ -1,4 +1,5 @@
 # 3.3 Go如何使得Web工作
+
 前面小节介绍了如何通过Go搭建一个Web服务，我们可以看到简单应用一个net/http包就方便的搭建起来了。那么Go在底层到底是怎么做的呢？万变不离其宗，Go的Web服务工作也离不开我们第一小节介绍的Web工作方式。
 
 ## web工作方式的几个概念
@@ -33,46 +34,117 @@ Handler：处理请求和生成返回信息的处理逻辑
 - 如何接收客户端请求？
 - 如何分配handler？
 
-前面小节的代码里面我们可以看到，Go是通过一个函数`ListenAndServe`来处理这些事情的，这个底层其实这样处理的：初始化一个server对象，然后调用了`net.Listen("tcp", addr)`，也就是底层用TCP协议搭建了一个服务，然后监控我们设置的端口。
+前面小节的代码里面我们可以看到，Go是通过一个函数`ListenAndServe`来处理这些事情的，其实现源码如下：
+
+```Go
+func ListenAndServe(addr string, handler Handler) error {
+	server := &Server{Addr: addr, Handler: handler}
+	return server.ListenAndServe()
+}
+
+```
+
+`ListenAndServe`会初始化一个`sever`对象，然后调用了`Server`对象的方法`ListenAndServe`。其源码如下：
+
+```Go
+func (srv *Server) ListenAndServe() error {
+	if srv.shuttingDown() {
+		return ErrServerClosed
+	}
+	addr := srv.Addr
+	if addr == "" {
+		addr = ":http"
+	}
+	ln, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+	return srv.Serve(ln)
+}
+
+```
+
+`ListenAndServe`调用了`net.Listen("tcp", addr)`，也就是底层用TCP协议搭建了一个服务，最后调用`src.Serve`监控我们设置的端口。监控之后如何接收客户端的请求呢？
+
+`Serve`的具体实现如下(为突出重点，仅展示关键代码)，通过下面的分析源码我们可以看到客户端请求的具体处理过程：
 
-下面代码来自Go的http包的源码，通过下面的代码我们可以看到整个的http处理过程：
 ```Go
 
 func (srv *Server) Serve(l net.Listener) error {
-	defer l.Close()
+	...
-	var tempDelay time.Duration // how long to sleep on accept failure
+
+	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
 	for {
-		rw, e := l.Accept()
+		rw, err := l.Accept()
-		if e != nil {
+		...
-			if ne, ok := e.(net.Error); ok && ne.Temporary() {
+
-				if tempDelay == 0 {
+		connCtx := ctx
-					tempDelay = 5 * time.Millisecond
+		if cc := srv.ConnContext; cc != nil {
-				} else {
+			connCtx = cc(connCtx, rw)
-					tempDelay *= 2
+			if connCtx == nil {
+				panic("ConnContext returned nil")
 			}
-				if max := 1 * time.Second; tempDelay > max {
-					tempDelay = max
-				}
-				log.Printf("http: Accept error: %v; retrying in %v", e, tempDelay)
-				time.Sleep(tempDelay)
-				continue
-			}
-			return e
 		}
 		tempDelay = 0
-		c, err := srv.newConn(rw)
+		c := srv.newConn(rw)
-		if err != nil {
+		c.setState(c.rwc, StateNew, runHooks) // before Serve can return
-			continue
+		go c.serve(connCtx)
-		}
-		go c.serve()
 	}
 }
 
 ```
-监控之后如何接收客户端的请求呢？上面代码执行监控端口之后，调用了`srv.Serve(net.Listener)`函数，这个函数就是处理接收客户端的请求信息。这个函数里面起了一个`for{}`，首先通过Listener接收请求，其次创建一个Conn，最后单独开了一个goroutine，把这个请求的数据当做参数扔给这个conn去服务：`go c.serve()`。这个就是高并发体现了，用户的每一次请求都是在一个新的goroutine去服务，相互不影响。
 
-那么如何具体分配到相应的函数来处理请求呢？conn首先会解析request:`c.readRequest()`,然后获取相应的handler:`handler := c.server.Handler`，也就是我们刚才在调用函数`ListenAndServe`时候的第二个参数，我们前面例子传递的是nil，也就是为空，那么默认获取`handler = DefaultServeMux`,那么这个变量用来做什么的呢？对，这个变量就是一个路由器，它用来匹配url跳转到其相应的handle函数，那么这个我们有设置过吗?有，我们调用的代码里面第一句不是调用了`http.HandleFunc("/", sayhelloName)`嘛。这个作用就是注册了请求`/`的路由规则，当请求uri为"/"，路由就会转到函数sayhelloName，DefaultServeMux会调用ServeHTTP方法，这个方法内部其实就是调用sayhelloName本身，最后通过写入response的信息反馈到客户端。
+这个函数里面起了一个`for{}`，首先通过Listener接收请求：`l.Accept()`，其次创建一个Conn：`c := srv.newConn(rw)`，最后单独开了一个goroutine，把这个请求的数据当做参数扔给这个conn去服务：`go c.serve(connCtx)`。这个就是高并发体现了，用户的每一次请求都是在一个新的goroutine去服务，相互不影响。
 
+那么如何具体分配到相应的函数来处理请求呢？我们继续分析conn的`serve`方法，其源码如下(为突出重点，仅展示关键代码)：
+
+```Go
+func (c *conn) serve(ctx context.Context) {
+    ...
+
+	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)
+        ...
+
+		// HTTP cannot have multiple simultaneous active requests.[*]
+		// Until the server replies to this request, it can't read another,
+		// so we might as well run the handler in this goroutine.
+		// [*] Not strictly true: HTTP pipelining. We could let them all process
+		// in parallel even if their responses need to be serialized.
+		// But we're not going to implement HTTP pipelining because it
+		// was never deployed in the wild and the answer is HTTP/2.
+		serverHandler{c.server}.ServeHTTP(w, w.req)
+		w.cancelCtx()
+        ...
+
+	}
+}
+```
+
+conn首先会解析request:`w, err := c.readRequest(ctx)`, 然后获取相应的handler去处理请求:`serverHandler{c.server}.ServeHTTP(w, w.req)`，`ServeHTTP`的具体实现如下：
+
+```Go
+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)
+}
+```
+
+`sh.srv.Handler`就是我们刚才在调用函数`ListenAndServe`时候的第二个参数，我们前面例子传递的是nil，也就是为空，那么默认获取`handler = DefaultServeMux`,那么这个变量用来做什么的呢？对，这个变量就是一个路由器，它用来匹配url跳转到其相应的handle函数，那么这个我们有设置过吗?有，我们调用的代码里面第一句不是调用了`http.HandleFunc("/", sayhelloName)`嘛。这个作用就是注册了请求`/`的路由规则，当请求uri为"/"，路由就会转到函数sayhelloName，DefaultServeMux会调用ServeHTTP方法，这个方法内部其实就是调用sayhelloName本身，最后通过写入response的信息反馈到客户端。
 
 详细的整个流程如下图所示：
 
@@ -82,8 +154,8 @@ func (srv *Server) Serve(l net.Listener) error {
 
 至此我们的三个问题已经全部得到了解答，你现在对于Go如何让Web跑起来的是否已经基本了解了呢？
 
-
 ## links
-   * [目录](<preface.md>)
+
-   * 上一节: [GO搭建一个简单的web服务](<03.2.md>)
+* [目录](<preface.md>)
-   * 下一节: [Go的http包详解](<03.4.md>)
+* 上一节: [GO搭建一个简单的web服务](<03.2.md>)
+* 下一节: [Go的http包详解](<03.4.md>)