基于 gorilla/mux 包学习路由分发之路由定义和请求分发

学习完 Go 语言的基础知识，接下来，我们来学习 Go Web 编程。遵循程序员的传统，我们从 Web 应用版"Hello World"式服务开始。

首先，我们基于 HTTP 编程中介绍的 net/http 包来实现一个简单的 HTTP 服务器作为 Web 服务器：

package main

import (
	"fmt"
	"log"
	"net/http"
	"strings"
)

func sayHelloWorld(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()                   // 解析参数
	fmt.Println(r.Form)             // 在服务端打印请求参数
	fmt.Println("URL:", r.URL.Path) // 请求 URL
	fmt.Println("Scheme:", r.URL.Scheme)
	for k, v := range r.Form {
		fmt.Println(k, ":", strings.Join(v, ""))
	}
	fmt.Fprintf(w, "Hello JIeJaitt！") // 发送响应到客户端
}

func main() {
	http.HandleFunc("/", sayHelloWorld)
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}

在这段代码中，我们在入口函数中通过 http.HandleFunc() 方法定义了一个路由 / 和对应的路由处理函数 sayHelloWorld（在该函数中，r 代表请求对象，w 代表响应对象），然后通过 http.ListenAndServe 启动这个 HTTP 服务器，并设置监听端口为 8080。

接下来，我们对 Go 语言实现的简易 Web 应用进行测试，要启动 Golang 的 HTTP 服务器，需要在对应代码所在目录运行如下代码：

go run server.go

然后在浏览器中请求 http://localhost:8080，页面显示如下：

服务端也会输出对应的请求日志：

然后我们在客户端请求中带上参数信息：

此时，服务端就会打印对应的参数字段值出来：

Go 语言 HTTP 请求处理的底层机制

我们创建了第一个 Go Web 应用，这篇教程我们来简单分析下基于 Go 语言编写的 Web 应用底层是如何处理 HTTP 请求的。

客户端发起的 HTTP 请求是通过 Go 语言实现的 HTTP 服务器监听、接收、处理并返回响应的，这个 HTTP 服务器底层工作流程如下：

1. 创建 Listen Socket，监听指定的端口，等待客户端请求到来；
2. Listen Socket 接收客户端的请求，得到 Client Socket，接下来通过 Client Socket 与客户端通信；
3. 处理客户端的请求，首先从 Client Socket 读取 HTTP 请求的协议头, 如果是 POST 方法, 还可能要读取客户端提交的数据，然后交给相应的 Handler（处理器）处理请求，Handler 处理完毕后装载好客户端需要的数据，最后通过 Client Socket 返回给客户端。

上述流程对应的是上一篇 server.go 源码中的如下这两行代码：

http.HandleFunc("/", sayHelloWorld)
err := http.ListenAndServe(":9091", nil)

有关处理器绑定的路由与对应方法的实现细节，我们后面介绍路由、请求、表单、响应、视图等实现时会详细介绍，这里我们先将注意力放到 http.ListenAndServe 这行代码，看看底层到底做了些什么。

关于这个方法的使用我们在 HTTP 编程之 HTTP/HTTPS 请求处理这篇教程中已经简单介绍过，这里，我们更深入系统的研究下底层的处理逻辑。

创建 Listen Socket 监听端口

该方法底层调用的是 net/http 包的 ListenAndServe 方法，首先会初始化一个 Server 对象，然后调用该 Server 实例的 ListenAndServe 方法，进而调用 net.Listen("tcp", addr)，也就是基于 TCP 协议创建 Listen Socket，并在传入的IP 地址和端口号上监听请求，在本例中，IP 地址为空，默认是本机地址，端口号是 8080：

// ListenAndServe listens on the TCP network address addr and then calls
// Serve with handler to handle requests on incoming connections.
// Accepted connections are configured to enable TCP keep-alives.
//
// The handler is typically nil, in which case the DefaultServeMux is used.
//
// ListenAndServe always returns a non-nil error.
func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

// ListenAndServe listens on the TCP network address srv.Addr and then
// calls Serve to handle requests on incoming connections.
// Accepted connections are configured to enable TCP keep-alives.
//
// If srv.Addr is blank, ":http" is used.
//
// ListenAndServe always returns a non-nil error. After Shutdown or Close,
// the returned error is ErrServerClosed.
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)
}

接收客户端请求并建立连接

创建 Listen Socket 成功后，调用 Server 实例的 Serve(net.Listener) 方法，用来接收并处理客户端的请求信息。这个方法里面起了一个 for 循环，在循环体中首先通过 net.Listener（即上一步监听端口中创建的 Listen Socket）实例的 Accept 方法接收客户端请求，接收到请求后根据请求信息创建一个 conn 连接实例，最后单独开了一个 goroutine，把这个请求的数据当做参数扔给这个 conn 去服务：

// Serve accepts incoming connections on the Listener l, creating a
// new service goroutine for each. The service goroutines read requests and
// then call srv.Handler to reply to them.
//
// HTTP/2 support is only enabled if the Listener returns *tls.Conn
// connections and they were configured with "h2" in the TLS
// Config.NextProtos.
//
// Serve always returns a non-nil error and closes l.
// After Shutdown or Close, the returned error is ErrServerClosed.
func (srv *Server) Serve(l net.Listener) error {
	if fn := testHookServerServe; fn != nil {
		fn(srv, l) // call hook with unwrapped listener
	}

	origListener := l
	l = &onceCloseListener{Listener: l}
	defer l.Close()

	if err := srv.setupHTTP2_Serve(); err != nil {
		return err
	}

	if !srv.trackListener(&l, true) {
		return ErrServerClosed
	}
	defer srv.trackListener(&l, false)

	baseCtx := context.Background()
	if srv.BaseContext != nil {
		baseCtx = srv.BaseContext(origListener)
		if baseCtx == nil {
			panic("BaseContext returned a nil context")
		}
	}

	var tempDelay time.Duration // how long to sleep on accept failure

	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
	for {
		rw, err := l.Accept()
		if err != nil {
			select {
			case <-srv.getDoneChan():
				return ErrServerClosed
			default:
			}
			if ne, ok := err.(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", err, tempDelay)
				time.Sleep(tempDelay)
				continue
			}
			return err
		}
		connCtx := ctx
		if cc := srv.ConnContext; cc != nil {
			connCtx = cc(connCtx, rw)
			if connCtx == nil {
				panic("ConnContext returned nil")
			}
		}
		tempDelay = 0
		c := srv.newConn(rw)
		c.setState(c.rwc, StateNew, runHooks) // before Serve can return
		go c.serve(connCtx)
	}
}

这个就是高并发体现了，用户的每一次请求都是在一个新的 goroutine 去服务，相互不影响。客户端请求的具体处理逻辑都是在 c.serve 中完成的。

处理客户端请求并返回响应

接下来，我们进入 conn 实例的 serve 方法源码，看看底层如何将 HTTP 请求分配给指定处理器方法进行处理。

conn 首先会通过 c.readRequest() 解析请求，然后在 serverHandler{c.server}.ServeHTTP(w, w.req) 的 ServeHTTP 方法中获取相应的 handler：handler := c.server.Handler，也就是我们刚才在调用函数 ListenAndServe 时候的第二个参数。

我们在上篇教程的示例中传递的是 nil，则默认会获取 DefaultServeMux, 这个 handler 变量其实就是一个路由器，它用来匹配 URL 路由与对应的处理函数，而这个映射关系在 main 函数的第一行代码中就完成了：http.HandleFunc("/", sayHelloWorld)，其作用就是注册了请求 / 的路由规则，当请求 URL 路由为 /，就会跳转到函数 sayhelloWorld 来处理请求，DefaultServeMux 会调用 ServeHTTP 方法，这个方法内部其实就是调用 sayhelloWorld 方法本身（在 Go 语言中函数本身是第一类公民，可以当作实现了 Handler 接口的类型，只不过对应的的 ServeHTTP 方法内部调用的是函数自身而已），最后通过写入 ResponseWriter 对象将响应返回到客户端：

// 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{}
	}

	if req.URL != nil && strings.Contains(req.URL.RawQuery, ";") {
		var allowQuerySemicolonsInUse int32
		req = req.WithContext(context.WithValue(req.Context(), silenceSemWarnContextKey, func() {
			atomic.StoreInt32(&allowQuerySemicolonsInUse, 1)
		}))
		defer func() {
			if atomic.LoadInt32(&allowQuerySemicolonsInUse) == 0 {
				sh.srv.logf("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
			}
		}()
	}

	handler.ServeHTTP(rw, req)
}

当然，对于复杂的逻辑，我们也可以自己实现 Handler 接口并将对象实例作为 http.ListenAndServe 的第二个参数传入。

这里的逻辑可以类比为 Laravel 框架中的路由定义来学习，对于默认的 DefaultServeMux 实现，可以理解为基于匿名函数实现的路由规则定义，对于自定义 Handler 接口实现的处理器，可以理解为基于控制器实现的路由规则定义。

对于 Go Web 应用 HTTP 请求的底层处理，就简单介绍到这里，你最好结合源码来阅读和理解。¹

参考文献