Go Web：Handler

Multiplexer根據URL將請求路由給指定的Handler。Handler用於處理請求並給予響應。更嚴格地說，用來讀取請求體、並將請求對應的響應字段(respones header)寫入ResponseWriter中，而後返回。

什麼是Handler

什麼是Handler。它是一個接口，定義在net/http/server.go中：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

也就是說，實現了ServerHTTP方法的都是Handler。注意ServerHTTP方法的參數：http.ResponesWriter接口和Request指針。

在Handler的註釋中，給出了幾點主要的說明：

1. Handler用於響應一個HTTP request
   
2. 接口方法ServerHTTP應該用來將response header和須要響應的數據寫入到ResponseWriter中，而後返回。返回意味着這個請求已經處理結束，不能再使用這個ResponseWriter、不能再從Request.Body中讀取數據，不能併發調用已完成的ServerHTTP方法
   
3. handler應該先讀取Request.Body，而後再寫ResponseWriter。只要開始向ResponseWriter寫數據後，就不能再從Request.Body中讀取數據
   
4. handler只能用來讀取request的body，不能修改已取得的Request(由於它的參數Request是指針類型的)

ResponseWriter接口說明

再看看ResponseWriter接口的定義：

// 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.
type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
}

註釋中已經說明，ResponseWriter接口的做用是用於構造HTTP response。且明確指定了Handler.ServerHTTP方法返回之後就不能再使用ResponseWriter了。

這個接口有3個方法：

• Header()方法用來構造響應Header，它返回一個Header對象，這個Header對象稍後將被WriterHeader()響應出去。Header類型是一個map類型的結構，字段名爲key、字段值爲value：
  type Header map[string][]string
• Write()方法用於向網絡鏈接中寫響應數據。
  
• WriteHeader()方法將給定的響應狀態碼和響應Header一塊兒發送出去。

很顯然，ResponseWriter的做用是構造響應header，並將響應header和響應數據經過網絡連接發送給客戶端。

再看ListenAndServe()

在啓動go http自帶的web服務時，調用了函數ListenAndServe()。這個函數的定義以下：

func ListenAndServe(addr string, handler Handler) error

該函數有兩個參數，第一個參數是自帶的web監聽地址和端口，第二個參數是Handler，用來處理每一個接進來的http request，但通常第二個參數設置爲nil，表示調用默認的Multiplexer：DefaultServeMux。這個默認的ServeMux惟一的做用，是將請求根據URL路由給對應的handler進行處理。

var DefaultServeMux = &defaultServeMux

這裏有兩個問題：

• (1).第二個參數爲何建議設置爲nil
  
• (2).設置爲nil後，DefaultServeMux是請求的路由器，它爲何能夠充當一個handler

先看第二個問題，很簡單，由於ServeMux類型定義了ServeHTTP()方法，它實現了Handler接口：

type ServeMux struct {
        // Has unexported fields.
}
func NewServeMux() *ServeMux
func (mux *ServeMux) Handle(pattern string, handler Handler)
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)

前面說過，只要實現了ServerHTTP()方法的類型，就是一個Handler。而DefaultServeMux是默認的ServeMux，因此它是一個Handler。

關於第一個問題，看一個示例就知道了。

package main

import (
    "fmt"
    "net/http"
)

// MyHandler實現Handler接口
type MyHandler struct{}

func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World!\n")
}

func main() {
    handler := MyHandler{}
    server := http.Server{
        Addr:    "127.0.0.1:8080",
        Handler: &handler,      // 以&handler做爲第二個參數
    }
    server.ListenAndServe()
}

上面的示例中定義了一個handler，它實現的ServeHTTP()方法只有一個做用，輸出Hello World!。而且將這個handler做爲ListenAndServe()的第二個參數。

注意，上面以&handler做爲參數而非handler，由於此處MyHandler中實現的ServerHTTP()方法的receiver是指針類型的，因此MyHandler的實例對象也必須是指針類型的，如此才能實現Handler接口。

啓動這個web服務後，以不一樣的URL去訪問它，將老是獲得徹底相同的響應結果：

很顯然，當handler做爲ListenAndServe()的第二個參數時，任意請求都會使用這個惟一的handler進行處理。

因此，建議將第二個參數設置爲nil(或者上面的Serve Struct不指定Handler字段)，它表示調用默認的DefaultServeMux做爲handler，使得每一個訪問請求都會調用這個特殊的handler，而這個handler的做用是將請求根據url路由給不一樣的handler。

另外須要注意的是，http包中提供的Handle()和HandleFunc()函數實際上是DefaultServeMux.XXX的封裝，因此直接調用http.Handle()和http.HandleFunc()其實是在調用DefaultServeMux.Handle()和DefaultServeMux.HandleFunc()。

func Handle(pattern string, handler Handler) {
    DefaultServeMux.Handle(pattern, handler)
}

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

使用DefaultServeMux後的Handler示例

下面是使用了DefaultServeMux的示例。

建立了兩個handler，一個handler用於對應/hello，該handler用於輸出Hello，另外一個handler用於對應world，該handler用於輸出World：

package main

import (
    "fmt"
    "net/http"
)

type HelloHandler struct{}
type WorldHandler struct{}

func (h *HelloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello\n")
}
func (h *WorldHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "World\n")
}

func main() {
    helloHandler := HelloHandler{}
    worldHandler := WorldHandler{}
    server := http.Server{
        Addr:    "127.0.0.1:8080",
    }
    http.Handle("/hello",&helloHandler)
    http.Handle("/world",&worldHandler)
    server.ListenAndServe()
}

下面是訪問的結果：

HandleFunc是什麼

除了使用Handle處理http請求，也能使用HandleFunc()處理。

先看一個使用HandleFunc()處理請求的示例，示例的效果和前文是同樣的。

package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello\n")
}

func world(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "World\n")
}

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

    server.ListenAndServe()
}

下面是訪問的結果：

Go有一個函數HandleFunc()，它表示使用第二個參數的函數做爲handler，處理匹配到的url路徑請求。

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

不難看出，HandleFunc()使得咱們能夠直接使用一個函數做爲handler，而不須要自定義一個實現Handler接口的類型。正如上面的示例中，咱們沒有定義Handler類型，也沒有去實現ServeHTTP()方法，而是直接定義函數，並將其做爲handler。

換句話說，HandleFunc()使得咱們能夠更簡便地爲某些url路徑註冊handler。可是，使用HandleFunc()畢竟是圖簡便，有時候不得不使用Handle()，好比咱們肯定要定義一個type。

Handle()、HandleFunc()和Handler、HandlerFunc的關係

說實話，一開始感受挺亂的。

Handle()和HandleFunc()是函數，用來給url綁定handler。Handler和HandlerFunc類型，用來處理請求。

看Handle()、HandleFunc()以及Handler、HandlerFunc的定義就已經很清晰了：

func Handle(pattern string, handler Handler) {}
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {}

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)

Handle()和HandleFunc()都是爲某個url路徑模式綁定一個對應的handler，只不過HandleFunc()是直接使用函數做爲handler，而Handle()是使用Handler類型的實例做爲handler。

Handler接口的實例都實現了ServeHTTP()方法，都用來處理請求並響應給客戶端。

HandlerFunc類型不是接口，但它有一個方法ServeHTTP()，也就是說HandlerFunc其實也是一種Handler。

由於HandlerFunc是類型，只要某個函數的簽名是func(ResponseWriter, *Request)，它就是HandlerFunc類型的一個實例。另外一方面，這個類型的實例(多是參數、多是返回值類型)能夠和某個簽名爲func(ResponseWriter, *Request)的函數進行互相賦值。這個過程可能很隱式，但確實常常出現相關的用法。

例如：

// 一個函數類型的handler
func myhf(ResponseWriter, *Request){}

// 以HandlerFunc類型做爲參數類型
func a(hf HandlerFunc){}

// 因此，能夠將myhf做爲a()的參數
a(myhf)

實際上，可使用HandlerFunc()進行轉換。例若有一個函數world()，它的參數是合理的，使用HandlerFunc(world)表示將其轉換爲一個Handler。這個轉換、適應在後面會常常用到。

例如：

// 兩個函數
func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello\n")
}

func world(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "World\n")
}

func main() {
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    // 第一個使用HandleFunc()爲路徑註冊hello()函數handler
    // 第二個使用Handle()爲路徑註冊轉換後的handler
    http.HandleFunc("/hello", hello)
    http.Handle("/world", http.HandlerFunc(world))

    server.ListenAndServe()
}

上面的示例中，Handle()函數的第二個參數要求的是Handler類型，使用http.HandlerFunc(world)就將函數world()轉換成了Handler類型的一個實例。

鏈式handler

handler是用來處理http請求的，處理過程可能會很簡單，也可能會很複雜。複雜的狀況下，可能沒法使用一個單獨的handler來完成工做，畢竟handler只是一個函數。儘管咱們能夠直接在這個函數中調用其它函數。

很常常地，可能handler中須要嵌套其它handler，甚至多層嵌套，這就是鏈式handler。

因爲Handle()或HandleFunc()註冊的時候須要指定參數類型，因此handler嵌套的時候，也要關注handler的參數類型以及返回類型。看下面示例就會明白參數類型和返回類型是怎麼要求的。

HandleFunc()的嵌套示例

代碼以下：

package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World!\n")
}

func log(hf http.HandlerFunc) http.HandlerFunc {
    count := 0
    return func(w http.ResponseWriter, r *http.Request) {
        count++
        fmt.Printf("Handler Function called %d times\n", count)
        hf(w, r)
    }
}

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

屢次訪問http://127.0.0.1:8080/hello，將在瀏覽器中輸出"Hello World!"，但同時會在運行這個go程序的終端上屢次輸出如下內容：

$ go run test.go
Handler Function called 1 times
Handler Function called 2 times
Handler Function called 3 times
Handler Function called 4 times
Handler Function called 5 times

上面的示例中，主要看下面兩段代碼：

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World!\n")
}

func log(hf http.HandlerFunc) http.HandlerFunc {
    count := 0
    return func(w http.ResponseWriter, r *http.Request) {
        count++
        fmt.Printf("Handler Function called %d times\n", count)
        hf(w, r)
    }
}

hello()是一個普通的HandlerFunc類型函數，由於它的簽名符合HandlerFunc類型，因此它是HandlerFunc類型的一個實例。而log()函數正是以HandlerFunc類型做爲參數的，因此前面的示例代碼中，將hello函數做爲了log函數的參數：

http.HandleFunc("/hello", log(hello))

HandleFunc()的第二個參數要求是HandlerFunc類型的，因此log()的返回值是HandlerFunc類型。在log()中，使用匿名函數做爲它的返回值，這裏的這個匿名函數是一個閉包(由於引用了外層函數的變量hf和count)。這個匿名函數最後調用hf(w,r)，因爲hf是HandlerFunc類型的一個實例，因此能夠如此調用。

上面體現了HandlerFunc嵌套時候關於參數以及返回值的一些細節。

上面的示例中還有一個細節須要引發注意：爲何每次訪問時，上面的count都會記住以前的值並自增，而不是重置爲0後自增。

之因此有這個疑問，多是認爲每次訪問時，請求處理完成後handler就退出了，閉包雖然會記住外層函數的自由變量count，但也會由於處理完成後退出，致使每次訪問都重置爲0後自增。但實際上，handler是註冊在給定路徑上的，只要web服務沒有退出，這個handler就一直不會退出，不會由於每次訪問都從新註冊handler。因此，閉包handler一直引用着hf和count這兩個自由變量。

HandlerFunc嵌套Handler

將上面的HandlerFunc嵌套HandlerFunc修改一下，變成Handler嵌套HandlerFunc。

package main

import (
    "fmt"
    "net/http"
)

type MyHandler struct{}

func (wh *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World!\n")
}

func log(h http.Handler) http.Handler {
    count := 0
    f := func(w http.ResponseWriter, r *http.Request) {
        count++
        fmt.Printf("Handler Function called %d times\n", count)
        h.ServeHTTP(w, r)
    }
    return http.HandlerFunc(f)
}

func main() {
    myHandler := MyHandler{}
    server := http.Server{
        Addr: "127.0.0.1:8080",
    }
    http.Handle("/hello", log(&myHandler))
    server.ListenAndServe()
}

邏輯也很簡單，無非是將HandlerFunc轉換成Handler。

思考一下，Handler是否能夠嵌套Handler，或者Handler嵌套HandlerFunc。能夠，可是很不方便，由於ServeHTTP()方法限制了無法調用其它的Handler，除非定義的某個Handler是嵌套在某個Handler類型中的類型。