Go Web编程--深入学习解析HTTP请求

之前这个系列的文章一直在讲用 Go语言怎么编写HTTP服务器来提供服务，如何给服务器配置路由来匹配请求到对应的处理程序，如何添加中间件把一些通用的处理任务从具体的Handler中解耦出来，以及如何更规范地在项目中应用数据库。不过一直漏掉了一个环节是服务器接收到请求后如何解析请求拿到想要的数据， Go语言使用 net/http包中的 Request结构体对象来表示 HTTP请求，通过 Request结构对象上定义的方法和数据字段，应用程序能够便捷地访问和设置 HTTP请求中的数据。

一般服务端解析请求的需求有如下几种

• HTTP请求头中的字段值

• URL 查询字符串中的字段值

• 请求体中的 Form表单数据

• 请求体中的 JSON格式数据

• 读取客户端的上传的文件

今天这篇文章我们就按照这几种常见的服务端对 HTTP请求的操作来说一下服务器应用程序如何通过 Request对象解析请求头和请求体。

Request 结构定义

在说具体操作的使用方法之前我们先来看看 net/http包中 Request结构体的定义，了解一下 Request拥有什么样的数据结构。 Request结构在源码中的定义如下。

1. type Request struct {

2. Method string

3. URL *url.URL

4. Proto string // "HTTP/1.0"

5. ProtoMajor int // 1

6. ProtoMinor int // 0

7. Header Header

8. Body io.ReadCloser

9. GetBody func() (io.ReadCloser, error)

10. ContentLength int64

11. TransferEncoding []string

12. Close bool

13. Host string

14. Form url.Values

15. PostForm url.Values

16. MultipartForm *multipart.Form

17. Trailer Header

18. RemoteAddr string

19. RequestURI string

20. TLS *tls.ConnectionState

21. Cancel <-chan struct{}

22. Response *Response

23. ctx context.Context

24. }

我们快速地了解一下每个字段大致的含义，了解了每个字段的含义在不同的应用场景下需要读取访问 HTTP请求的不同部分时就能够有的放矢了。

Method

指定HTTP方法（GET，POST，PUT等）。

URL

URL指定要请求的URI（对于服务器请求）或要访问的URL（用于客户请求）。它是一个表示 URL的类型 url.URL的指针， url.URL的结构定义如下：

1. type URL struct {

2. Scheme string

3. Opaque string

4. User *Useri

5. Host string

6. Path string

7. RawPath string

8. ForceQuery bool

9. RawQuery string

10. Fragment string

11. }

Proto

Proto， ProtoMajor， ProtoMinor三个字段表示传入服务器请求的协议版本。对于客户请求，这些字段将被忽略。 HTTP客户端代码始终使用 HTTP/1.1或 HTTP/2。

Header

Header包含服务端收到或者由客户端发送的 HTTP请求头，该字段是一个 http.Header类型的指针， http.Header类型的声明如下：

1. type Header map[string][]string

是 map[string][]string类型的别名， http.Header类型实现了 GET， SET， Add等方法用于存取请求头。如果服务端收到带有如下请求头的请求：

1. Host: example.com

2. accept-encoding: gzip, deflate

3. Accept-Language: en-us

4. fOO: Bar

5. foo: two

那么 Header的值为：

1. Header = map[string][]string{

2. "Accept-Encoding": {"gzip, deflate"},

3. "Accept-Language": {"en-us"},

4. "Foo": {"Bar", "two"},

5. }

对于传入的请求， Host标头被提升为 Request.Host字段，并将其从 Header对象中删除。 HTTP 定义头部的名称是不区分大小写的。 Go使用 CanonicalHeaderKey实现的请求解析器使得请求头名称第一个字母以及跟随在短横线后的第一个字母大写其他都为小写形式，比如： Content-Length。对于客户端请求，某些标头，例如 Content-Length和 Connection会在需要时自动写入，并且标头中的值可能会被忽略。

Body

这个字段的类型是 io.ReadCloser， Body是请求的主体。对于客户端发出的请求， nil主体表示该请求没有 Body，例如 GET请求。 HTTP客户端的传输会负责调用 Close方法。对于服务器接收的请求，请求主体始终为非 nil，但如果请求没有主体，则将立即返回 EOF。服务器将自动关闭请求主体。服务器端的处理程序不需要关心此操作。

GetBody

客户端使用的方法的类型，其声明为：

1. GetBody func() (io.ReadCloser, error)

ContentLength

ContentLength记录请求关联内容的长度。值-1表示长度未知。值>=0表示从 Body 中读取到的字节数。对于客户请求，值为0且非 nil的 Body也会被视为长度未知。

TransferEncoding

TransferEncoding为字符串切片，其中会列出从最外层到最内层的传输编码， TransferEncoding通常可以忽略；在发送和接收请求时，分块编码会在需要时自动被添加或者删除。

Close

Close表示在服务端回复请求或者客户端读取到响应后是否要关闭连接。对于服务器请求，HTTP服务器会自动处理 并且处理程序不需要此字段。对于客户请求，设置此字段为 true可防止重复使用到相同主机的请求之间的TCP连接，就像已设置 Transport.DisableKeepAlives一样。

Host

对于服务器请求， Host指定URL所在的主机，为防止DNS重新绑定攻击，服务器处理程序应验证 Host标头具有的值。 http库中的 ServeMux（复用器）支持注册到特定 Host的模式，从而保护其注册的处理程序。对于客户端请求， Host可以用来选择性地覆盖请求头中的 Host，如果不设置， Request.Write使用 URL.Host来设置请求头中的 Host。

Form

Form包含已解析的表单数据，包括 URL字段的查询参数以及 PATCH， POST或 PUT表单数据。此字段仅在调用 Request.ParseForm之后可用。 HTTP客户端会忽略 Form并改用 Body。 Form字段的类型是 url.Values类型的指针。 url.Values类型的声明如下：

1. 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。

RemoteAddr

RemoteAddr允许 HTTP服务器和其他软件记录发送请求的网络地址，通常用于记录。 net/http包中的HTTP服务器在调用处理程序之前将 RemoteAddr设置为“ IP：端口”， HTTP客户端会忽略此字段。

RequestURI

RequestURI是未修改的 request-target客户端发送的请求行（RFC 7230，第3.1.1节）。在服务器端，通常应改用URL字段。在HTTP客户端请求中设置此字段是错误的。

Response

Response字段类型为 *Response，它指定了导致此请求被创建的重定向响应，此字段仅在客户端发生重定向时被填充。

ctx

ctx 是客户端上下文或服务器上下文。它应该只通过使用 WithContext复制整个 Request进行修改。这个字段未导出以防止人们错误使用 Context并更改同一请求的调用方所拥有的上下文。

读取请求头

上面分析了 Go将 HTTP请求头存储在 Request结构体对象的 Header字段里， Header字段实质上是一个 Map，请求头的名称为Map key， MapValue的类型为字符串切片，有的请求头像 Accept会有多个值，在切片中就对应多个元素。

Header类型的 Get方法可以获取请求头的第一个值，

1. func exampleHandler(w http.ResponseWriter, r *http.Request) {

2. ua := r.Header.Get("User-Agent")

3. ...

4. }

或者是获取值时直接通过 key获取对应的切片值就好，比如将上面的改为：

1. ua := r.Header["User-Agent"]

下面我们写个遍历请求头信息的示例程序，同时也会通上面介绍的 Request结构中定义的 Method， URL， Host， RemoteAddr等字段把请求的通用信息打印出来。在我们一直使用的 http_demo项目中增加一个 DisplayHeadersHandler，其源码如下：

1. package handler

2. import (

3. "fmt"

4. "net/http"

5. )

6. func DisplayHeadersHandler(w http.ResponseWriter, r *http.Request) {

7. fmt.Fprintf(w, "Method: %s URL: %s Protocol: %s \n", r.Method, r.URL, r.Proto)

8. // 遍历所有请求头

9. for k, v := range r.Header {

10. fmt.Fprintf(w, "Header field %q, Value %q\n", k, v)

11. }

12. fmt.Fprintf(w, "Host = %q\n", r.Host)

13. fmt.Fprintf(w, "RemoteAddr= %q\n", r.RemoteAddr)

14. // 通过 Key 获取指定请求头的值

15. fmt.Fprintf(w, "\n\nFinding value of \"Accept\" %q", r.Header["Accept"])

16. }

将其处理程序绑定到 /index/display_headers路由上：

1. indexRouter.HandleFunc("/display_headers", handler.DisplayHeadersHandler)

然后启动项目，打开浏览器访问:

1. http://localhost:8000/index/display_headers

可以看到如下输出：

http_demo项目中已经添加了本文中所有示例的源码，公众号内回复 gohttp06可以获取源码的下载链接。

获取URL参数值

GET请求中的 URL查询字符串中的参数可以通过 url.Query()，我们来看一下啊 url.Query()函数的源码：

1. func (u *URL) Query() Values {

2. v, _ := ParseQuery(u.RawQuery)

3. return v

4. }

它通过 ParseQuery函数解析 URL参数然后返回一个 url.Values类型的值。 url.Values类型上面我们已经介绍过了是 map[string][]string类型的别名，实现了 GET， SET， Add， Del等方法用于存取数据。

所以我们可以使用 r.URL.Query().Get("ParamName")获取参数值，也可以使用 r.URL.Query()["ParamName"]。两者的区别是 Get只返回切片中的第一个值，如果参数对应多个值时（比如复选框表单那种请求就是一个 name对应多个值），记住要使用第二种方式。

我们通过运行一个示例程序 display_url_params.go来看一下两种获取 URL参数的区别

1. package handler

2. import (

3. "fmt"

4. "net/http"

5. )

6. func DisplayUrlParamsHandler(w http.ResponseWriter, r *http.Request) {

7. for k, v := range r.URL.Query() {

8. fmt.Fprintf(w, "ParamName %q, Value %q\n", k, v)

9. fmt.Fprintf(w, "ParamName %q, Get Value %q\n", k, r.URL.Query().Get(k))

10. }

11. }

将其处理程序绑定到 /index/display_url_params路由上：

1. indexRouter.HandleFunc("/display_url_params", handler.DisplayUrlParamsHandler)

打开浏览器访问

1. http://localhost:8000/index/display_url_params?a=b&c=d&a=c

浏览器会输出：

1. ParamName "a", Value ["b" "c"]

2. ParamName "a", Get Value "b"

3. ParamName "c", Value ["d"]

4. ParamName "c", Get Value "d"

我们为参数 a传递了两个参数值，可以看到通过 url.Query.Get()只能读取到第一个参数值。

获取表单中的参数值

Request结构的 Form字段包含已解析的表单数据，包括 URL字段的查询参数以及 PATCH， POST或 PUT表单数据。此字段仅在调用 Request.ParseForm之后可用。不过 Request对象提供一个 FormValue方法来获取指定名称的表单数据， FormValue方法会根据 Form字段是否有设置来自动执行 ParseForm方法。

1. func (r *Request) FormValue(key string) string {

2. if r.Form == nil {

3. r.ParseMultipartForm(defaultMaxMemory)

4. }

5. if vs := r.Form[key]; len(vs) > 0 {

6. return vs[0]

7. }

8. return ""

9. }

可以看到 FormValue方法也是只返回切片中的第一个值。如果需要获取字段对应的所有值，那么需要通过字段名访问 Form字段。如下：

获取表单字段的单个值

1. r.FormValue(key)

获取表单字段的多个值

1. r.ParseForm()

2. r.Form["key"]

下面是我们的示例程序，以及对应的路由：

1. //handler/display_form_data.go

2. package handler

3. import (

4. "fmt"

5. "net/http"

6. )

7. func DisplayFormDataHandler(w http.ResponseWriter, r *http.Request) {

8. if err := r.ParseForm(); err != nil {

9. panic(err)

10. }

11. for key, values := range r.Form {

12. fmt.Fprintf(w, "Form field %q, Values %q\n", key, values)

13. fmt.Fprintf(w, "Form field %q, Value %q\n", key, r.FormValue(key))

14. }

15. }

16. //router.go

17. indexRouter.HandleFunc("/display_form_data", handler.DisplayFormDataHandler)

我们在命令行中使用 cURL命令发送表单数据到处理程序，看看效果。

1. curl -X POST -d 'username=James&password=123' \

2. http://localhost:8000/index/display_form_data

返回的响应如下：

1. Form field "username", Values ["James"]

2. Form field "username", Value "James"

3. Form field "password", Values ["123"]

4. Form field "password", Value "123"

获取Cookie

Request对象专门提供了一个 Cookie方法用来访问请求中携带的 Cookie数据，方法会返回一个 *Cookie类型的值以及 error。 Cookie类型的定义如下：

1. type Cookie struct {

2. Name string

3. Value string

4. Path string // optional

5. Domain string // optional

6. Expires time.Time // optional

7. RawExpires string // for reading cookies only

8. MaxAge int

9. Secure bool

10. HttpOnly bool

11. SameSite SameSite

12. Raw string

13. Unparsed []string

14. }

所以要读取请求中指定名称的 Cookie值，只需要

1. cookie, err := r.Cookie(name)

2. // 错误检查

3. ...

4. value := cookie.Value

Request.Cookies()方法会返回 []*Cookie切片，其中会包含请求中所有的 Cookie

下面的示例程序，会打印请求中所有的 Cookie

1. // handler/read_cookie.go

2. package handler

3. import (

4. "fmt"

5. "net/http"

6. )

7. func ReadCookieHandler(w http.ResponseWriter, r *http.Request) {

8. for _, cookie := range r.Cookies() {

9. fmt.Fprintf(w, "Cookie field %q, Value %q\n", cookie.Name, cookie.Value)

10. }

11. }

12. //router/router.go

13. indexRouter.HandleFunc("/read_cookie", handler.ReadCookieHandler)

我们通过 cURL在命令行请求 http://localhost:8000/index/read_cookie

1. curl --cookie "USER_TOKEN=Yes" http://localhost:8000/index/read_cookie

执行命令后会返回：

1. Cookie field "USER_TOKEN", Value "Yes"

解析请求体中的JSON数据

现在前端都倾向于把请求数据以 JSON格式放到请求主体中传给服务器，针对这个使用场景，我们需要把请求体作为 json.NewDecoder()的输入流，然后将请求体中携带的 JSON格式的数据解析到声明的结构体变量中

1. //handler/parse_json_request

2. package handler

3. import (

4. "encoding/json"

5. "fmt"

6. "net/http"

7. )

8. type Person struct {

9. Name string

10. Age int

11. }

12. func DisplayPersonHandler(w http.ResponseWriter, r *http.Request) {

13. var p Person

14. // 将请求体中的 JSON 数据解析到结构体中

15. // 发生错误，返回400 错误码

16. err := json.NewDecoder(r.Body).Decode(&p)

17. if err != nil {

18. http.Error(w, err.Error(), http.StatusBadRequest)

19. return

20. }

21. fmt.Fprintf(w, "Person: %+v", p)

22. }

23. // router/router.go

24. indexRouter.HandleFunc("/parse_json_request", handler.ParseJsonRequestHandler)

在命令行里用 cURL命令测试我们的程序：

1. curl -X POST -d '{"name": "James", "age": 18}' \

2. -H "Content-Type: application/json" \

3. http://localhost:8000/index/parse_json_request

返回响应如下：

1. Person: {Name:James Age:18}%

读取上传文件

服务器接收客户端上传的文件，使用 Request定义的 FormFile()方法。该方法会自动调用 r.ParseMultipartForm(32<<20)方法解析请求多部表单中的上传文件，并把文件可读入内存的大小设置为 32M（32向左位移20位），如果内存大小需要单独设置，就要在程序里单独调用 ParseMultipartForm()方法才行。

1. func ReceiveFile(w http.ResponseWriter, r *http.Request) {

2. r.ParseMultipartForm(32 << 20)

3. var buf bytes.Buffer

4. file, header, err := r.FormFile("file")

5. if err != nil {

6. panic(err)

7. }

8. defer file.Close()

9. name := strings.Split(header.Filename, ".")

10. fmt.Printf("File name %s\n", name[0])

11. io.Copy(&buf, file)

12. contents := buf.String()

13. fmt.Println(contents)

14. buf.Reset()

15. return

16. }

Go语言解析 HTTP请求比较常用的方法我们都介绍的差不多了。因为想总结全一点，篇幅还是有点长，不过整体不难懂，而且也可以下载程序中的源码自己运行调试，动手实践一下更有助于理解吸收。 HTTP客户端发送请求要设置的内容也只今天讲的 Request结构体的字段， Request对象也提供了一些设置相关的方法供开发人员使用，今天就先说这么多了。

公众号内回复 gohttp06可以下载文章中项目的源码，赶快下载下来自己试一试吧。

前文回顾