Go Web：處理請求

時間 2019-11-06

標籤 web 處理請求欄目 HTML 简体版

原文原文鏈接

處理請求

Request和Response

http Requset和Response的內容包括如下幾項：html

Request or response line
Zero or more headers
An empty line, followed by …
… an optional message body

例如一個http Request：web

GET /Protocols/rfc2616/rfc2616.html HTTP/1.1
Host: www.w3.org
User-Agent: Mozilla/5.0
(empty line)

若是是POST方法，在empty line後還包含請求體。json

一個http Response：瀏覽器

HTTP/1.1 200 OK
Content-type: text/html
Content-length: 24204
(empty line)
and then 24,204 bytes of HTML code

go http包分爲兩種角色：http Client和http Server。http Client能夠發送請求，好比寫爬蟲程序時語言扮演的角色就是http Client；http Server用來提供web服務，能夠處理http請求並響應。網絡

對於Request，做爲http客戶端(如編寫爬蟲類工具)常須要關注的是URL和User-Agent以及其它幾個Header；做爲http服務端(web服務端，處理請求)常須要關注的幾項是：併發

URL
Header
Body
Form,、PostForm、MultipartForm

如下是完整的Request結構以及相關的函數、方法：混個眼熟就行了app

type Request struct {
        Method string
        URL *url.URL
        Header Header
        Body io.ReadCloser
        GetBody func() (io.ReadCloser, error)  // Server: x, Cleint: √
        ContentLength int64
        TransferEncoding []string
        Close bool                 // Server: x, Cleint: √
        Host string
        Form url.Values
        PostForm url.Values
        MultipartForm *multipart.Form
        Trailer Header
        RemoteAddr string
        RequestURI string           // x
        TLS *tls.ConnectionState
        Cancel <-chan struct{}      // x
        Response *Response          // x
}

func NewRequest(method, url string, body io.Reader) (*Request, error)
func ReadRequest(b *bufio.Reader) (*Request, error)
func (r *Request) AddCookie(c *Cookie)
func (r *Request) BasicAuth() (username, password string, ok bool)
func (r *Request) Context() context.Context
func (r *Request) Cookie(name string) (*Cookie, error)
func (r *Request) Cookies() []*Cookie
func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)
func (r *Request) FormValue(key string) string
func (r *Request) MultipartReader() (*multipart.Reader, error)
func (r *Request) ParseForm() error
func (r *Request) ParseMultipartForm(maxMemory int64) error
func (r *Request) PostFormValue(key string) string
func (r *Request) ProtoAtLeast(major, minor int) bool
func (r *Request) Referer() string
func (r *Request) SetBasicAuth(username, password string)
func (r *Request) UserAgent() string
func (r *Request) WithContext(ctx context.Context) *Request
func (r *Request) Write(w io.Writer) error
func (r *Request) WriteProxy(w io.Writer) error

注意有哪些字段和方法，字段的詳細說明見go doc http.Request。上面打了"x"的表示不須要了解的或者廢棄的。curl

有一個特殊的字段Trailer，它是Header類型的，顯然它存放的是一個個請求header，它表示請求發送完成以後再發送的額外的header。對於Server來講，讀取了request.Body以後纔會讀取Trailer。不多有瀏覽器支持HTTP Trailer功能。ide

如下是完整的Response結構以及相關的函數、方法：混個眼熟就行了函數

type Response struct {
        Status     string // e.g. "200 OK"
        StatusCode int    // e.g. 200
        Proto      string // e.g. "HTTP/1.0"
        ProtoMajor int    // e.g. 1
        ProtoMinor int    // e.g. 0
        Header Header
        Body io.ReadCloser
        ContentLength int64
        TransferEncoding []string
        Close bool
        Uncompressed bool
        Trailer Header
        Request *Request
        TLS *tls.ConnectionState
}

func Get(url string) (resp *Response, err error)
func Head(url string) (resp *Response, err error)
func Post(url string, contentType string, body io.Reader) (resp *Response, err error)
func PostForm(url string, data url.Values) (resp *Response, err error)
func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)
func (r *Response) Cookies() []*Cookie
func (r *Response) Location() (*url.URL, error)
func (r *Response) ProtoAtLeast(major, minor int) bool
func (r *Response) Write(w io.Writer) error

其實有些直接從字面意思看就知道了。

URL

內容太多，見：Go Web：URLs

Http Header

Request和Response結構中都有Header字段，Header是一個map結構。

type Header map[string][]string
    A Header represents the key-value pairs in an HTTP header.

func (h Header) Add(key, value string)
func (h Header) Del(key string)
func (h Header) Get(key string) string
func (h Header) Set(key, value string)
func (h Header) Write(w io.Writer) error
func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error

key是Header字段名，value是Header字段的值，同個字段多個值放在string的slice中。

Add()、Del()、Get()、Set()意義都很明確。

Write()是將Header寫進Writer中，好比從網絡鏈接中發送出去。WriteSubSet()和Write()相似，但能夠指定exclude[headerkey]==true排除不寫的字段。

下面是一個示例：

package main

import (
    "fmt"
    "net/http"
)

func headers(w http.ResponseWriter, r *http.Request) {
    for key := range r.Header {
        fmt.Fprintf(w, "%s: %s\n", key, r.Header[key])
    }
    fmt.Fprintf(w, "--------------\n")
    fmt.Fprintf(w, "the key: %s\n", r.Header["Accept-Encoding"])
    fmt.Fprintf(w, "the key: %s\n", r.Header.Get("Accept-Encoding"))
}
func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/headers", headers)
    server.ListenAndServe()
}

瀏覽器中訪問http://127.0.0.1:8080/headers的結果：

Connection: [keep-alive]
Cache-Control: [max-age=0]
Upgrade-Insecure-Requests: [1]
User-Agent: [Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36]
Accept: [text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8]
Accept-Encoding: [gzip, deflate, br]
Accept-Language: [zh-CN,zh;q=0.9,en;q=0.8]
--------------
the key: [gzip, deflate, br]
the key: gzip, deflate, br

Http Body

Request和Response結構中都有Body字段，它們都是io.ReadCloser接口類型。從名字能夠看出，io.ReadCloser由兩個接口組成：Reader和Closer，意味着它實現了Reader接口的Read()方法，也實現了Closer接口的Close()方法。這意味着Body的實例能夠調用Read()方法，也能夠調用Close()方法。

例如，下面寫一個handler，從請求中讀取Body並輸出：

package main

import (
    "fmt"
    "net/http"
)

func body(w http.ResponseWriter, r *http.Request) {
    len := r.ContentLength
    body := make([]byte, len)
    r.Body.Read(body)
    fmt.Fprintf(w, "%s\n", string(body))
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/body", body)
    server.ListenAndServe()
}

由於使用HTTP Get方法的Request沒有Body，因此這裏使用curl的"-d"選項來構造一個POST請求，併發送Request Body：

$ curl -id "name=lognshuai&age=23" 127.0.0.1:8080/body
HTTP/1.1 200 OK
Date: Mon, 26 Nov 2018 09:04:40 GMT
Content-Length: 22
Content-Type: text/plain; charset=utf-8

name=lognshuai&age=23

Go和HTML Form

在Request結構中，有3個和form有關的字段：

// Form字段包含了解析後的form數據，包括URL的query、POST/PUT提交的form數據
// 該字段只有在調用了ParseForm()以後纔有數據
Form url.Values

// PostForm字段不包含URL的query，只包括POST/PATCH/PUT提交的form數據
// 該字段只有在調用了ParseForm()以後纔有數據
PostForm url.Values // Go 1.1

// MultipartForm字段包含multipart form的數據
// 該字段只有在調用了ParseMultipartForm()以後纔有數據
MultipartForm *multipart.Form

因此，通常的邏輯是：

先調用ParseForm()或ParseMultipartForm()解析請求中的數據
按需訪問Request結構中的Form、PostForm或MultipartForm字段

除了先解析再訪問字段的方式，還能夠直接使用Request的方法：

FormValue(key)
PostFormValue(key)

稍後解釋這兩個方法。

取Form和PostForm字段

給定一個html文件，這個html文件裏是form表單：

<html>
  <head>    
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Go Web</title>
  </head>
  <body>
    <form action=http://127.0.0.1:8080/process?name=xiaofang&boyfriend=longshuai
      method="post" enctype="application/x-www-form-urlencoded">
      <input type="text" name="name" value="longshuai"/>
      <input type="text" name="age" value="23"/>
      <input type="submit"/>
    </form>
  </body>
</html>

在這個form裏，action指定了要訪問的url，其中path=process，query包含name和boyfriend兩個key。除此以外，form表單的input屬性裏，也定義了name和age兩個key，因爲method爲post，這兩個key是做爲request body發送的，且由於enctype指定爲application/x-www-form-urlencoded，這兩個key會按照URL編碼的格式進行組織。

下面是web handler的代碼：

package main

import (
    "fmt"
    "net/http"
)

func form(w http.ResponseWriter, r *http.Request) {
    r.ParseForm()
    fmt.Fprintf(w, "%s\n", r.Form)
    fmt.Fprintf(w, "%s\n", r.PostForm)
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/process", form)
    server.ListenAndServe()
}

上面先使用ParseForm()方法解析Form，再訪問Request中的Form字段和PostForm字段。

打開前面的Html文件，點擊"提交"後，將輸出：

map[name:[longshuai xiaofang] age:[23] boyfriend:[longshuai]]
map[name:[longshuai] age:[23]]

若是這時，將application/x-www-form-urlencoded改爲multipart/form-data，再點擊提交，將輸出：

map[name:[xiaofang] boyfriend:[longshuai]]
map[]

顯然，使用multipart/form-data編碼form的時候，編碼的內容沒有放進Form和PostForm字段中，或者說編碼的結果無法放進這兩個字段中。

取MultipartForm字段

要取MultipartForm字段的數據，先使用ParseMultipartForm()方法解析Form，解析時會讀取全部數據，但須要指定保存在內存中的最大字節數，剩餘的字節數會保存在臨時磁盤文件中。

package main

import (
    "fmt"
    "net/http"
)

func form(w http.ResponseWriter, r *http.Request) {
    r.ParseMultipartForm(1024)
    fmt.Fprintf(w,"%s\n",r.Form)
    fmt.Fprintf(w,"%s\n",r.PostForm)
    fmt.Fprintf(w,"%s\n",r.MultipartForm)

}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/process", form)
    server.ListenAndServe()
}

將html文件的enctype改成multipart/form-data後，從新點開html文件，將輸出：

map[name:[xiaofang longshuai] boyfriend:[longshuai] age:[23]]
map[name:[longshuai] age:[23]]
&{map[name:[longshuai] age:[23]] map[]}

前兩行結果意味着ParseMultipartForm()方法也調用了ParseForm()方法，使得除了設置MultipartForm字段，也會設置Form字段和PostForm字段。

注意上面的第三行，返回的是一個struct，這個struct中有兩個map，第一個map是來自form的key/value，第二個map爲空，這個見後面的File。

最後還需注意的是，enctype=multipart/form-data和enctype=application/x-www-form-urlencoded時，Request.Form字段中key的保存順序是不一致的：

// application/x-www-form-urlencoded
map[name:[longshuai xiaofang] age:[23] boyfriend:[longshuai]]

// multipart/form-data
map[name:[xiaofang longshuai] boyfriend:[longshuai] age:[23]]

FormValue()和PostFormValue()

前面都是先調用ParseForm()或ParseMultipartForm()解析Form後再調用Request中對應字段的。還能夠直接調用FormValue()或PostFormValue()方法。

FormValue(key)
PostFormValue(key)

這兩個方法在須要時會自動調用ParseForm()或ParseMultipartForm()，因此使用這兩個方法取Form數據的時候，能夠不用顯式解析Form。

FormValue()返回form數據和url query組合後的第一個值。要取得完整的值，仍是須要訪問Request.Form或Request.PostForm字段。但由於FormValue()已經解析過Form了，因此無需再顯式調用ParseForm()再訪問request中Form相關字段。

PostFormValue()返回form數據的第一個值，由於它只能訪問form數據，因此忽略URL的query部分。

先看FormValue()方法的使用。注意，下面調用了FormValue()以後沒有調用ParseForm()和ParseMultipartForm()解析Form，就能夠直接訪問Request中和Form相關的3個字段。

package main

import (
    "fmt"
    "net/http"
)

func form(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w,"%s\n",r.FormValue("name"))
    fmt.Fprintf(w,"%s\n",r.FormValue("age"))
    fmt.Fprintf(w,"%s\n",r.FormValue("boyfriend"))
    fmt.Fprintf(w,"%s\n",r.Form)
    fmt.Fprintf(w,"%s\n",r.PostForm)
    fmt.Fprintf(w,"%s\n",r.MultipartForm)
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/process", form)
    server.ListenAndServe()
}

當enctype=multipart/form-data時，會自動調用ParseMultipartForm()，輸出結果：

xiaofang
23
longshuai
map[name:[xiaofang longshuai] boyfriend:[longshuai] age:[23]]
map[name:[longshuai] age:[23]]
&{map[name:[longshuai] age:[23]] map[]}

當enctype=application/x-www-form-urlencoded時，會自動調用ParseForm()，輸出結果：

longshuai
23
longshuai
map[name:[longshuai xiaofang] age:[23] boyfriend:[longshuai]]
map[name:[longshuai] age:[23]]
%!s(*multipart.Form=<nil>)

仍然注意，由於兩種enctype致使的Request.Form存儲key時的順序不一致，使得訪問有多個值的key獲得的結果不一致。

再看PostFormValue()方法的使用。

package main

import (
    "fmt"
    "net/http"
)

func form(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w,"%s\n",r.PostFormValue("name"))
    fmt.Fprintf(w,"%s\n",r.PostFormValue("age"))
    fmt.Fprintf(w,"%s\n",r.PostFormValue("boyfriend"))
    fmt.Fprintf(w,"%s\n",r.Form)
    fmt.Fprintf(w,"%s\n",r.PostForm)
    fmt.Fprintf(w,"%s\n",r.MultipartForm)
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/process", form)
    server.ListenAndServe()
}

當enctype=multipart/form-data時，會自動調用ParseMultipartForm()，輸出結果：

longshuai
23

map[name:[xiaofang longshuai] boyfriend:[longshuai] age:[23]]
map[name:[longshuai] age:[23]]
&{map[name:[longshuai] age:[23]] map[]}

當enctype=application/x-www-form-urlencoded時，會自動調用ParseForm()，輸出結果：

longshuai
23

map[age:[23] boyfriend:[longshuai] name:[longshuai xiaofang]]
map[name:[longshuai] age:[23]]
%!s(*multipart.Form=<nil>)

注意，因爲PostFormValue()方法只能訪問form數據，上面調用了PostFormValue()後，沒法使用PostFormValue()訪問URL中的query的Key/value，儘管request中的字段都合理設置了。

Files

multipart/form-data最經常使用的場景多是上傳文件，好比在form中使用file標籤。如下是html文件：

<html>
  <head>    
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Go Web Programming</title>
  </head>
  <body>
    <form action=http://127.0.0.1:8080/process?name=xiaofang&boyfriend=longshuai
      method="post" enctype="multipart/form-data">
      <input type="text" name="name" value="longshuai"/>
      <input type="text" name="age" value="23"/>
      <input type="file" name="file_to_upload">
      <input type="submit"/>
    </form>
  </body>
</html>

下面是服務端接收上傳文件數據的代碼：

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func form(w http.ResponseWriter, r *http.Request) {
    r.ParseMultipartForm(1024)
    fileHeader := r.MultipartForm.File["file_to_upload"][0]
    file, err := fileHeader.Open()
    if err == nil {
        dataFromFile, err := ioutil.ReadAll(file)
        if err == nil {
            fmt.Fprintf(w, "%s\n", dataFromFile)
        }
    }
    fmt.Fprintf(w, "%s\n", r.MultipartForm)
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/process", form)
    server.ListenAndServe()
}

上面先調用ParseMultipartForm()解析multipart form，而後訪問request的MultipartForm字段，這個字段的類型是*multipart.Form，該類型定義在mime/multipart/formdata.go文件中：

$ go doc multipart.Form
package multipart // import "mime/multipart"

type Form struct {
        Value map[string][]string
        File  map[string][]*FileHeader
}

Form類型表示解析後的multipart form，字段File和Value都是map類型的，其中File的map value是*FileHeader類型：

$ go doc multipart.fileheader
package multipart // import "mime/multipart"

type FileHeader struct {
        Filename string
        Header   textproto.MIMEHeader
        Size     int64

        // Has unexported fields.
}
    A FileHeader describes a file part of a multipart request.


func (fh *FileHeader) Open() (File, error)

它實現了Open()方法，因此能夠直接調用Open()來打開multipart.Form的File部分。即：

fileHeader := r.MultipartForm.File["file_to_upload"][0]
file, err := fileHeader.Open()

而後讀取這段數據，響應給客戶端。注意，有了File後，request.MultipartForm字段的第二個map就有了值，第二個map對應的就是multipart.Form.File的內容。

整個返回結果以下：

FormFile()

相似於FormValue()和PostFormValue()方法的便捷，讀取multipart.Form也有快捷方式：

$ go doc http.formfile
func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)
    FormFile returns the first file for the provided form key. FormFile calls
    ParseMultipartForm and ParseForm if necessary.

FormFile()方法會在須要的時候自動調用parseMultipartForm()或ParseForm()。注意它的返回值。由於第一個返回值爲multipart.File，說明至少實現了io.Reader接口，能夠直接讀取這個文件。

修改上一節的示例：

func form(w http.ResponseWriter, r *http.Request) {
    file, _, err := r.FormFile("file_to_upload")

    if err != nil {
        panic(err)
    }
    dataFromFile, err := ioutil.ReadAll(file)
    if err != nil {
        panic(err)
    }
    fmt.Fprintf(w, "%s\n", dataFromFile)
}

ResponseWriter

ResponseWriter接口用於發送響應數據、響應header。它有3個方法：

type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
}
    A ResponseWriter interface is used by an HTTP handler to construct an HTTP
    response.

    A ResponseWriter may not be used after the Handler.ServeHTTP method has
    returned.

Header()用於構造response header，構造好的header會在稍後自動被WriteHeader()發送出去。好比設置一個Location字段：

w.Header().Set("Location", "http://google.com")

Write()用於發送響應數據，例如發送html格式的數據，json格式的數據等。

str := `<html>
<head><title>Go Web Programming</title></head>
<body><h1>Hello World</h1></body>
</html>`
w.Write([]byte(str))

WriteHeader(int)能夠接一個數值HTTP狀態碼，同時它會將構造好的Header自動發送出去。若是不顯式調用WriteHeader()，會自動隱式調用併發送200 OK。

下面是一個示例：

package main

import (
    "fmt"
    "encoding/json"
    "net/http"
)

func commonWrite(w http.ResponseWriter, r *http.Request) {
    str := `<html>
        <head>
            <title>Go Web</title>
        </head>
        <body>
            <h1>Hello World</h1>
        </body>
    </html>`
    w.Write([]byte(str))
}

func writeHeader(w http.ResponseWriter,r *http.Request){
    w.WriteHeader(501)
    fmt.Fprintln(w,"not implemented service")
}

func header(w http.ResponseWriter,r *http.Request){
    w.Header().Set("Location","http://www.baidu.com")
    w.WriteHeader(302)
}

type User struct {
    Name    string
    Friends []string
}

func jsonWrite(w http.ResponseWriter, r *http.Request) {
    var user = &User{
        Name:    "longshuai",
        Friends: []string{"personA", "personB", "personC"},
    }
    w.Header().Set("Content-Type", "application/json")
    jsonData, _ := json.Marshal(user)
    w.Write(jsonData)
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.HandleFunc("/commonwrite", commonWrite)
    http.HandleFunc("/writeheader", writeHeader)
    http.HandleFunc("/header", header)
    http.HandleFunc("/jsonwrite", jsonWrite)
    server.ListenAndServe()
}

commonWrite()這個handler用於輸出帶html格式的數據。訪問結果：

writeheader()這個handler用於顯式發送501狀態碼。訪問結果：

$ curl -i 127.0.0.1:8080/writeheader
HTTP/1.1 501 Not Implemented
Date: Tue, 27 Nov 2018 03:36:57 GMT
Content-Length: 24
Content-Type: text/plain; charset=utf-8

not implemented service

header()這個handler用於設置響應的Header，這裏設置了302重定向，客戶端收到302狀態碼後會找Location字段的值，而後重定向到http://www.baidu.com。

jsonWrite()這個handler用於發送json數據，因此發送以前先設置了Content-Type: application/json。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。