学习完 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()/sayHelloWorldrwhttp.ListenAndServe8080

接下来，我们对 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/httpListenAndServeServerServerListenAndServenet.Listen("tcp", addr)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)
}

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

ServerServe(net.Listener)fornet.ListenerAcceptconnconn
// 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)
	}
}

c.serve

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

connserve
connc.readRequest()serverHandler{c.server}.ServeHTTP(w, w.req)ServeHTTPhandlerhandler := c.server.HandlerListenAndServe
nilDefaultServeMuxhandlermainhttp.HandleFunc("/", sayHelloWorld)//sayhelloWorldDefaultServeMuxServeHTTPsayhelloWorldHandlerResponseWriter
// 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)
}

Handlerhttp.ListenAndServe
DefaultServeMuxHandler

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

参考文献