用Go实现一个http server非常容易，Go语言标准库net/http自带了一系列结构和方法来帮助我们简化HTTP服务开发的相关流程。因此，我们不需要依赖任何第三方组件就能构建并启动一个高并发的HTTP服务器。我们学习如何用net/http自己编写实现一个HTTP Serverk 并探究其实现原理，以此来更加深入了解并学习网络编程的常见范式以及设计思路
一、思考一些问题
(1) http 协议的具体格式是什么样子的？
（2）服务器是如何接收请求的？
（3） POST 请求的数据放在哪里，服务器如何识别和解析这些 POST 数据？
（4）如何关闭服务器？
二、HTTP服务处理流程
基于HTTP构建的服务标准模型包括两个端，客户端(Client) 和 服务端(Server)。HTTP请求从客户端发出，服务端接收到请求后进行处理然后将响应返回给客户端。所以http服务器的工作就在于如何接收来自客户端的请求，并向客户端返回响应。典型的HTTP服务的处理流程如下：
服务器在接收到请求时，首先会进入路由(router)，也成为服务复用器(Multiplexe)，路由的工作在于为请求找到对应的处理器(Handler)，处理器对接收到的请求进行相应处理后构建响应并返回给客户端。Go实现的http server遵循这样的处理流程。下面来看看简单地例子：
package main
import (
"fmt"
"net/http"
)
func HelloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "hello world")
}
type HiHandlerStruct struct {
content string
}
func (c HiHandlerStruct) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, c.content)
}
func main() {
http.HandleFunc("/hello", HelloHandler)
http.Handle("/hi", &HiHandlerStruct{content: "Hi"})
http.ListenAndServe(":8080", nil)
}Go实现的http服务步骤非常简单，首先注册路由，然后创建服务并开启监听即可。
Go实现http服务的几个步骤：注册路由、开启服务、处理请求以及关闭服务
1、注册路由
http.Handle 和 http.HandleFunc 都是用于给路由规则指定处理器，http.HandleFunc的第一个参数为路由的匹配规则(pattern)，也就是路径，第二个参数是一个签名为 func(w http.ResponseWriter, r *http.Requests) 的函数，http.Handle的第二个参数为实现了http.Handler接口的类型的实例。http.HandleFunc 和 http.Handle 的源码如下：
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
if handler == nil {
panic("http: nil handler")
}
mux.Handle(pattern, HandlerFunc(handler))
}func Handle(pattern string, handler Handler) {
DefaultServeMux.Handle(pattern, handler)
}
可以看到这两个函数最终都由 DefaultServeMux调用 Handler方法来完成路由处理器的注册。这里我们遇到两种类型的对象：ServeMux和Handler。我们先来看看Handler是什么：
//http.Handler是net/http中定义的接口，用来表示HTTP请求
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}Handler接口中声明了名为ServeHTTP的函数签名，也就是说任何结构只要实现了这个ServeHTTP方法，那么这个结构就是一个Handler对象。其实go的http服务都是基于Handler进行处理，而Handler对象的ServeHTTP方法会读取Request进行逻辑处理然后向ResponseWriter中写入响应的头部信息和响应内容。
在上面的HandleFunc函数，它调用了 *ServeMux.HandleFunc 将处理器注册到指定路由规则上：
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
if handler == nil {
panic("http: nil handler")
}
mux.Handle(pattern, HandlerFunc(handler))
}这里的HandlerFunc实际上是将handler函数做了一个类型转换，将函数转换为了 http.HandlerFunc 类型(注意：注册路由时调用的是HandleFunc，这里类型时http.HandlerFunc)。看一下HandlerFunc的定义：type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}HandlerFunc类型表示的是一个具有 func(ResponseWriter, *Request) 签名的函数类型，并且这种类型实现了ServeHTTP方法（在其实现的ServeHTTP方法中又调用了被转换的函数自身）。也就是说这个类型的函数其实就是一个Handler类型的对象。利用这种类型转换，我们可以将具有 func(ResponseWriter, *Reuqest) 签名的普通函数转换为一个Handler对象，而不需要定义一个结构体，再让这个结构实现ServeHTTP方法。
HandlerFunc 类型是一个允许将普通函数用作 HTTP 处理程序的适配器。 如果 f 是具有适当签名的函数，则 HandlerFunc(f) 是调用 f 的 Handler。
上面的代码中可以看到不论是使用 http.HandleFunc 还是 http.Handle 注册路由的处理函数最后都会用到ServeMux结构的Handler方法去注册路由处理函数。先来看看ServeMux的定义：
type ServeMux struct {
mu sync.RWMutex
m map[string]muxEntry
es []muxEntry // slice of entries sorted from longest to shortest.
hosts bool // whether any patterns contain hostnames
}
type muxEntry struct {
h Handler
pattern string
}ServeMux是一个服务复用器。字段m是一个map，key是路由表达式，value是一个muxEntry结构，muxEntry结构体存储了路由表达式和对应的handler。字段m对应的map用于路由的精确匹配，而es字段的slice会用于路由的部分匹配。ServeMux 是一个 HTTP 请求多路复用器。 它将每个传入请求的 URL 与已注册模式列表进行匹配，并为与 URL 最匹配的模式调用处理程序。ServeMux也实现了ServeHTTP方法，也是一个Handler对象：
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
}
h, _ := mux.Handler(r)
h.ServeHTTP(w, r)
}也就是说ServeMux结构体也是Handler对象，只不过ServeMux的ServeHTTP方法不是用来处理具体的 request 和构建 response，而是用来通过路由查找对应的路由处理器 Handler 对象，再去调用路由处理器的ServeHTTP方法去处理 request 和 构建response。
现在明白了 Handler 和 ServeMux 之后，再回来看之前的代码：
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
func Handle(pattern string, handler Handler) {
DefaultServeMux.Handle(pattern, handler)
}var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux
这里的DefaultServeMux表示一个默认的ServeMux实例，在上面的例子中我们没有创建自定义的ServeMux，而是"nil"，所以会自动使用DefaultServeMux。再来看一下ServeMux的Handle方法是怎么注册路由的处理函数的：
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
if pattern == "" {
panic("http: invalid pattern")
}
if handler == nil {
panic("http: nil handler")
}
if _, exist := mux.m[pattern]; exist { //路由已经注册过处理函数时，直接pannic
panic("http: multiple registrations for " + pattern)
}
if mux.m == nil {
mux.m = make(map[string]muxEntry)
}
e := muxEntry{h: handler, pattern: pattern} //用路由的pattern和处理函数创建的muxEntry对象
mux.m[pattern] = e //向ServeMux的m字段增加新的路由匹配规则
if pattern[len(pattern)-1] == '/' {
mux.es = appendSorted(mux.es, e) //如果路由patterm以'/'结尾，则将对应的muxEntry对象加入到[]muxEntry中，路由长的位于切片的前面
}
if pattern[0] != '/' {
mux.hosts = true
}
}Handle方法注册路由时主要做了两件事：一个就是向ServeMux的 map[string]muxEntry增加给定的路由匹配规则；然后如果路由表达式以 '/' 接轨，则将对应的muxEntry对象加入到[]muxEntry中，按照路由表达式长度倒叙排列。前者用于路由精确匹配，后者用于部分匹配。
通过http.NewServeMux() 可以创建一个ServeMux实例取代默认的DefaultServeMux。
package main
import (
"fmt"
"net/http"
)
type WelcomeHandlerStruct struct {
}
func HelloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "hello world")
}
func (*WelcomeHandlerStruct) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Welcome")
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", HelloHandler)
mux.Handle("/welcome", &WelcomeHandlerStruct{})
http.ListenAndServe(":8080", mux)
}ServeMux也实现了ServeHTTP方法，因此mux也是一个Handler对象。对于ListenAndServe() 方法，如果第二个参数是自定义的ServeMux实例，那么Serve实例接收到的ServeMux服务复用器将不再是DefaultServeMux而是mux。
2、启动服务
路由注册完成后，使用http.ListenAndServe 方法就能启动服务器开始监听指定端口发送过来的请求
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
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)
}这里首先创建了一个 Serve 对象，传入了地址和 handler 参数（这里的 handler 参数是 ServeMux 实例），然后调用 Server 对象 ListenAndServe() 方法。
先看一下Server这个结构体的定义，字段比较多：
type Server struct {
//可以选择要监听的服务器的tcp地址，格式为"host:port"。如果为空，则使用":http"（80）
Addr string
Handler Handler Listener
TLSConfig *tls.Config
ReadTimeout time.Duration
ReadHeaderTimeout time.Duration
WriteTimeout time.Duration
IdleTimeout time.Duration
MaxHeaderBytes int
TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
ConnState func(net.Conn, ConnState)
ErrorLog *log.Logger
BaseContext func(net.Listener) context.Context
ConnContext func(ctx context.Context, c net.Conn) context.Context
inShutdown atomicBool // true when server is in shutdown
disableKeepAlives int32 // accessed atomically.
nextProtoOnce sync.Once // guards setupHTTP2_* init
nextProtoErr error // result of http2.ConfigureServer if used
mu sync.Mutex
listeners map[*net.Listener]struct{}
activeConn map[*conn]struct{}
doneChan chan struct{}
onShutdown []func()
}在Server的ListenAndServe方法中，会初始化监听地址Addr，同时调用Listen方法设置监听。最后将监听的TCP对象传入其Serve方法。Serve对象的Serve方法会接收Listenner中过来的连接，为每个连接创建一个goroutine，在goroutine中会用路由器处理Handler对请求进行处理并构建响应。
func (srv *Server) Serve(l net.Listener) error {
......
baseCtx := context.Background()
......
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
for {
rw, err := l.Accept() //接收listener过来的网络连接请求
........
c := srv.newConn(rw)
c.setState(c.rwc, StateNew, runHooks) // before Serve can return//将连接放在Server.activeConn这个map中
go c.serve(connCtx) //创建协程处理请求
}
}这里隐去了一些细节，以便了解Serve方法的主要逻辑。首先创建一个上下文对象，然后调用Listener的Accept() 接收监听到的网络连接；一旦有新的连接建立，则调用Server的newConn() 创建新的连接对象，并将连接的状态标志为StateNew，然后开启一个goroutine处理连接请求。
在开启的goroutine中conn的serve()会进行路由匹配找到处理函数然后调用处理函数。这个方法很长，我们保留关键逻辑：
func (c *conn) serve(ctx context.Context) {
.........
for {
w, err := c.readRequest(ctx)
if c.r.remain != c.server.initialReadLimitSize() {
// If we read any bytes off the wire, we're active.
c.setState(c.rwc, StateActive, runHooks)
}
.........
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, runHooks)
c.curReq.Store((*response)(nil))
........
}
}当一个连接建立之后，该连接中所有的请求都将在这个协程中处理，直到连接被关闭。在serve()方法中会循环调用readRequest()方法读取下一个请求进行处理，其中最关键的逻辑是下面行代码：
serverHandler{c.server}.ServeHTTP(w, w.req)HTTP不能同时有多个active request.(HTTP/1.0) 。在服务器回复这个请求之前，他不能读取另一个请求 (HTTP/1.1:客户端并行传输，服务端串行接收),所以我们不放在这个goroutine中运行处理程序。HTTP并行传输，它们的响应需要序列化，让它们并行处理，实现HTTP管道(HTTP/2:HTTPS)。
serverHandler 是一个结构体类型，他会代理Server对象
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)
}在 serverHandler 实现的 ServeHTTP() 方法里的 sh.srv.Handler就是我们最初在ListenAndServe() 中传入的Handler参数，也就是我们自定义的ServeMux对象。如果该对象为nil，则会使用默认的DefaultServeMux。最后调用ServeMux的ServeHTTP方法匹配当前路由对应的handler方法。
在这里最终是调用handler.ServeHTTP(rw, req)，这里的handler要么是默认的DefaultServeMux，要么是自定义的ServeMux对象，所以这里的handler.ServeHTTP(rw, req) 是ServeMux对象实现的ServeHTTP(rw, req)
//ServeHTTP将请求分派给与Request URL最相近的handler
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
}
h, _ := mux.Handler(r)
h.ServeHTTP(w, r)
}
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
// CONNECT requests are not canonicalized.
if r.Method == "CONNECT" {
// If r.URL.Path is /tree and its handler is not registered,
// the /tree -> /tree/ redirect applies to CONNECT requests
// but the path canonicalization does not.
if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok {
return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
}
return mux.handler(r.Host, r.URL.Path)
}
// All other requests have any port stripped and path cleaned
// before passing to mux.handler.
host := stripHostPort(r.Host)
path := cleanPath(r.URL.Path)
// If the given path is /tree and its handler is not registered,
// redirect for /tree/.
if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
}
if path != r.URL.Path {
_, pattern = mux.handler(host, path)
u := &url.URL{Path: path, RawQuery: r.URL.RawQuery}
return RedirectHandler(u.String(), StatusMovedPermanently), pattern
}
return mux.handler(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 {
h, pattern = mux.match(host + path)
}
if h == nil {
h, pattern = mux.match(path)
}
if h == nil {
h, pattern = NotFoundHandler(), ""
}
return
}
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
// Check for exact match first.
v, ok := mux.m[path]
if ok {
return v.h, v.pattern
}
// Check for longest valid match. mux.es contains all patterns
// that end in / sorted from longest to shortest.
for _, e := range mux.es {
if strings.HasPrefix(path, e.pattern) {
return e.h, e.pattern
}
}
return nil, ""
}在match方法里我们看到之前提到的mux的m字段(类型为map[string]muxEntry) 和 es(类型为[]muxEntry)。这个方法里首先会利用m进行精确匹配，在map[string]muxEntry中查找是否有对应的路由规则存在；如果没有匹配的路由规则，则会利用es进行近似匹配。
注册路由时会把 '/' 结尾的路由 (可称为节点路由) 加入到es字段的[]muxEntry中。对于类似/path1/path2/path3这样的路由，如果不能找到精确的路由规则，那么则会去匹配和当前路由最接近的已注册的父节点路由，所以如果路由/path1/path2/已注册，那么该路由会被匹配，否则继续匹配下一个父节点路由，直到根路由/。
由于[]muxEntry中的muxEntry按照路由表达式从长倒短排序，所以进行近似匹配时匹配到的节点路由一定是已注册父节点路由中最相近的。
查找到路由时记得处理器Handler对象返回给调用者ServerMux.ServeHTTP方法，最后在方法里就会调用处理器Handler的ServeHTTP方法处理请求、构建写入响应。
h.ServeHTTP(w, r)实际上如果根据路由查找不到处理器Handler，那么也会返回NotFoundHandler：
func NotFound(w ResponseWriter, r *Request) {
Error(w, "404 page not found", StatusNotFound)
}
func NotFoundHandler() Handler {
return HandlerFunc(NotFound)
}这样标准统一，在调用h.ServeHTTP(w, r) 后则会向响应中写入404的错误信息。
3、处理请求
服务器收到请求后如何解析请求拿到想要的数据，Go语言使用net/http包中的Request结构体对象来表示HTTP请求，通过Request结构对象上定义的方法和数据字段。应用程序能够便捷地访问和设置HTTP请求中的数据。
一般服务端解析请求地需求有如下几种：
* HTTP请求头中地字段值
* URL查询字符串地字段值
* 请求体中的Form表单数据
* 请求体中的JSON格式数据
* 读取客户端的上传地文件
那么服务器应用程序是如何通过Request对象解析请求头和请求体的呢？
（1）Request结构的定义
先来看看net/http包中Request结构体的定义，了解以下Request拥有什么样的数据结构：
type Request struct {
Method string
URL *url.URL
Proto string // "HTTP/1.0"
ProtoMajor int // 1
ProtoMinor int // 0
Header Header
Body io.ReadCloser
GetBody func() (io.ReadCloser, error)
ContentLength int64
TransferEncoding []string
Close bool
Host string
Form url.Values
PostForm url.Values
MultipartForm *multipart.Form
Trailer Header
RemoteAddr string
RequestURI string
TLS *tls.ConnectionState
Cancel <-chan struct{}
Response *Response
ctx context.Context
}这里快速了解每个字段大致的含义，了解了每个字段的含义在不同的应用场景下需要读取访问HTTP请求的不同部分时就能够有的放矢了。
Method：指定的HTTP方法（GET、POST、PUT等）。
URL：URL指定要请求的URI（对于服务器请求）或要访问的URL（用于客户请求）。它是一个表示URL的类型url.URL的指针，url.URL的结构定义如下：
type URL struct {
Scheme string
Opaque string // encoded opaque data
User *Userinfo // username and password information
Host string // host or host:port
Path string // path (relative paths may omit leading slash)
RawPath string // encoded path hint (see EscapedPath method)
ForceQuery bool // append a query ('?') even if RawQuery is empty
RawQuery string // encoded query values, without '?'
Fragment string // fragment for references, without '#'
RawFragment string // encoded fragment hint (see EscapedFragment method)
}Proto：Proto，ProtoMajor，ProtoMinor三个字段表示传入服务器请求的协议版本。对于客户请求，这些字段将被忽略。HTTP客户端代码始终使用HTTP/1.1 或 HTTP/2。
Header：包含服务端收到或者由客户端发送的HTTP请求头，该字段是一个http.Header类型的指针，http.Header类型的声明如下：
type Header map[string][]string是map[string][ ]string 类型的别名，http.Header类型实现了Get，Set，Add等方法用于存取请求头。如果服务端收到带有如下请求头的请求：
Host : example.com
accept-encoding: gzip, deflate
Accept-Language: en-us
fOO: Bar
foo: two那么Header的值为：
Header = map[string][ ]string{
"Accept-Encoding": {"gzip, deflate"},
"Accept-Language": {"en-us"},
"Foo": {"Bar", "two"}
}对于传入的请求，Host标头被提升为Request.Host字段，并将其从Header对象中删除。HTTP定义头部的名称是不区分大小写。Go使用CanonicalHeaderKey实现的请求解析器使得请求头名称第一个字母以及跟随在短横线后的第一个字母大写其他都为小写形式，比如：Conten-Length。对于客户端请求，某些标头，例如Content-Length和Connection会在需要时自动写入，并且标头中的值可能会被忽略。
Body：这个字段的类型时io.ReadCloser，Body是请求的主体。对于客户端发出的请求，nil主体表示该请求没有Body，例如GET请求。HTTP客户端的传输会负责调用Close方法。对于服务器接受的请求，请求主体始终未非nil，但如果请求没有主体，则将立即返回EOF。服务器将自动关闭请求主体。服务器的处理程序不需要关心此操作。
GetBody：客户端使用的方法的类型，其声明为：
GetBody func() (io.ReadCloser, error)ContentLength：ContentLength记录请求关联内容的长度。值-1表示长度未知。值>=0表示从Body中读取到的字节数。对于客户请求，值为0且非nil的Body也会被视为长度未知。
TransferEncoding：TransferEncoding为字符串切片，其中会列出从最外层到最内层的传输编码，TransferEncoding通常可以忽略；在发送和接收请求时，分块编码会在需要时自动被添加或者删除。
Close：Close 表示在服务端回复请求或者读取到响应后是否要关闭连接。对于服务器请求，HTTP服务器会自动处理并且处理程序不需要此字段。对于客户请求，设置此字段为true可防止重复使用到相同主机的请求之间的TCP连接，就像一设置Transpoet.DisableKeepAlives一样。
Host：对于服务器请求，Host指定URL所在的主机，为防止DNS重新绑定攻击，服务器处理程序应验证Host标头具有的值。http库中的ServeMux(复用器)支持注册到特定Host的模式，从而保护其注册的处理程序。对于客户端请求，Host可以用来选择性地覆盖请求头中的Host，如果不设置，Request.Write使用URL.Host来设置请求头中的Host。
Form：Form包含已解析的表单数据，包括URL字段的查询参数以及PATH，POST或PUT表单数据。此字段仅在调用Request.ParseForm之后可用。HTTP客户端会忽略Form并改用Body。Form字段的类型是url.Values类型的指针。url.Values类类型的声明如下：
type Values map[string][]string也是map[string][ ]string 类型的别名。url.Values类型实现了GET，SET，Add，Del等方法用于存取表单数据。
PostForm：PostForm类型与Form字段一样，包含来自PATCH，POST的已解析表单数据或PUT主体参数。此字段仅在调用ParseForm之后可用。HTTP客户端会忽略PostForm并改用Body。
MultipartForm：MultipartForm是已解析的多部份表单数据，包括文件上传。仅在调用Request.ParseMultipartForm之后，此字段才可用。HTTP客户端会忽略MultipartForm并改用Body。该字段的类型时*multipart.Form。
type Form struct {
Value map[string][]string
File map[string][]*FileHeader
}RemoteAddr：RemoteAddr允许HTTP服务器和其他软件记录发送请求的网络地址，通常用于记录。net/http包中的HTTP服务器在调用处理程序之前将RemoteAddr设置为"IP：端口"，HTTP客户端会忽略此字段。
RequestURI：RequestURI是未修改的request-target客户端发送的请求行。在服务端，通常应改用URL字段。在HTTP客户端请求重设置此字段是错误的。
ctx：ctx是客户端上下文或服务器上下文。它应该只通过使用WithContext复制整个Request进行修改。这个字段未导出以防止人们错误使用Context并更改同一请求的调用方所拥有的上下文。
（2）读取请求头
Go将HTTP请求头存储在Request结构体对象的Header字段里，Header字段实质上是一个Map，请求头的名称未Map key， Map value的类型为字符串切片，有的请求头像Accept会有多个值，在切片中就对应多个元素。
Header类型的Get方法可以获取请求头的第一个值
func exampleHandler(w http.ResponseWriter, r *http.Request) {
ua := r.Header.Get("User-Agent")
...
}
//或者是获取值时直接通过key获取对应的切片值就好，比如将上面的改为：
ua := r.Header["User-Agent"]//demo
func DisplayHeadersHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Method: %s URL: %s Protocol: %s \n", r.Method, r.URL, r.Proto)
//遍历所有请求头
for k, v := range r.Header {
fmt.Fprintf(w, "Header field %q, Value %q\n", k, v)
}
fmt.Fprintf(w, "Host = %q\n", r.Host)
fmt.Fprintf(w, "RemoteAddr= %q\n", r.RemoteAddr)
fmt.Fprintf(w, "\n\nFinding value of \"Accept\" %q", r.Header["Accept"])
}
（3）获取URL参数：
GET请求中的URL查询字符串中的参数可以通过url.Query()，我们来看一下url.Query()函数的源码：
func (u *URL) Query() Values {
v, _ := ParseQuery(u.RawQuery)
return v
}它通过ParseQuery函数解析URL参数然后返回一个url.Values类型的值。url.Values类型是map[string][ ]string类型的别名，实现了GET，SET，Add，Del等方法用于存取数据。
所以我们可以使用r.URL.Quert().Get("ParamName") 获取参数值，也可以使用r.URL.Query()["paramName"]。两者的区别是Get只返回切片中的第一个值，如果参数对应多个值时（比如复选框表单那种请求就是一个name对应多个值），记住要使用第二种方式。
（4）获取表单中的参数值：
Request结构的Form字段包含已解析的表单数据，包括URL字段的查询参数以及PATCH，POST或PUT表单数据。此字段仅在调用Request.ParamForm之后可用。不过Request对象提供一个FormValue方法来获取指定名称的表单数据，FormValue方法会根据字段是否有设置来自动执行ParseForm方法。
func (r *Request) FormValue(key string) string {
if r.Form == nil {
r.ParseMultipartForm(defaultMaxMemory)
}
if vs := r.Form[key]; len(vs) > 0 {
return vs[0]
}
return ""
}
//获取表单字段的单个值
r.FormValue(key)
//获取表单字段的多个值
r.ParseForm()
r.Form["key"]可以看到FormValue方法也是只返回切片中的第一个值。如果需要获取字段对应的所有值，那么需要通过字段名访问Form字段。
（5）获取Cookie：
Reuqest对象专门提供了一个Cookie方法用来访问请求中携带的cookie数据，方法会返回一个 *Cookie类型的值以及 error。 Cookie类型的定义如下：
type Cookie struct {
Name string
Value string
Path string // optional
Domain string // optional
Expires time.Time // optional
RawExpires string // for reading cookies only
// MaxAge=0 means no 'Max-Age' attribute specified.
// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
// MaxAge>0 means Max-Age attribute present and given in seconds
MaxAge int
Secure bool
HttpOnly bool
SameSite SameSite
Raw string
Unparsed []string // Raw text of unparsed attribute-value pairs
} 所以要读取请求中指定名称的 Cookie值，只需要
cookie, err := r.Cookie(name)
value := cookie.Value Request.Cookies()方法会返回 []*Cookie切片，其中会包含请求中所有的 Cookie.
（6）解析请求体中的JSON数据
现在前端都倾向于把请求数据以 JSON格式放到请求主体中传给服务器，针对这个使用场景，我们需要把请求体作为 json.NewDecoder()的输入流，然后将请求体中携带的 JSON格式的数据解析到声明的结构体变量中。
type Person struct {
Name string
Age int
}
func DisplayPersonHandler(w http.ResponseWriter, r *http.Request) {
var p Person
// 将请求体中的 JSON 数据解析到结构体中
// 发生错误，返回400 错误码
err := json.NewDecoder(r.Body).Decode(&p)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
fmt.Fprintf(w, "Person: %+v", p)
}
//返回响应如下
Person{Name:James Age:18}%
（7）读取上传文件
服务器接收客户端上传的文件，使用Request定义的FormFile()方法。该方法会自动调用r.ParseMultipartForm(32 << 20)方法解析请求多部表单中的上传文件，并把文件可读入内存的大小设置为32M(32向左位移20位），如果内存大小需要单独设置，就要在程序里单独调用ParseMultipartForm()方法才行。
func ReceiveFile(w http.ResponseWriter, r *http.Request) {
r.ParseMultipartForm(32 << 20)
var buf bytes.Buffer
file, header, err := r.FormFile("file")
if err != nil {
panic(err)
}
defer file.Close()
name := strings.Split(header.Filename, ".")
fmt.Printf("File name %s\n", name[0])
io.Copy(&buf, file)
contents := buf.String()
fmt.Println(contents)
buf.Reset()
return
}
4.停止服务
我们写的http server已经能够监听网络连接，把请求路由到处理函数并处理请求了，但是还需要优雅的关停服务，在生产环境中，当需要更新服务端程序时需要重启服务，但此时可能有一部分请求进行到一般，如果强行中断这些请求可能会导致意外的结果。
从Go1.8 版本开始，net/http原生支持使用http.ShutDown方法来优雅关停HTTP服务。这种方案同样要求用户创建自定义的http.Server对象，因为ShutDown方法无法通过其它突进调用。
下面看这段代码，通过结合捕捉系统信号（Signal）、goroutine和管道（Channel）来实现服务器的优雅停止：
func main() {
mux := http.NewServeMux()
mux.Handle("/", &helloHandler{})
server := &http.Server{
Addr: ":8080",
Handler: mux,
}
//创建系统信号接收器
done := make(chan os.Signal)
signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
go func() {
<- done
if err := server.Shutdown(context.Background()); err != nil {
log.Fatal("Shutdown server:", err)
}
}()
log.Println("Starting HTTP server ... ")
err := server.ListenAndServe()
if err != nil {
if err == http.ErrServerClosed {
log.Printf("Server closed under request")
} else {
log.Fatal("Server closed unexpected")
}
}
}
type helloHandler struct{}
func (*helloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello World!")
}这段代码通过捕捉os.Interrupt信号(Ctrl+C) 和 syscall.SIGTERM信号（kill 进程时传递给进程的信号）然后调用 server.Shutdown 方法告知服务器应停止接受新的请求并在处理完当前已接受的请求后关闭服务器。为了与普通错误相区别，标准库提供了一个特定的错误类型 http.ErrServerClosed，我们可以在代码中通过判断是否为该错误类型来确定服务器是正常关闭的还是意外关闭的。
三、总结
上面就是用Go编写http server的基本的流程，当然离高性能的服务器还有很多要学习的地方，net/http标准库里还有很多结构和方法来完善http server，学会这些最基本的方法后再看其他Web 框架的代码时就清晰很多。甚至熟练了觉得框架用着太复杂也能自己封装一个HTTP 服务的脚手架。
