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的註釋中,給出了幾點主要的說明:
- Handler用於響應一個HTTP request
- 介面方法ServerHTTP應該用來將response header和需要響應的資料寫入到ResponseWriter中,然後返回。返回意味著這個請求已經處理結束,不能再使用這個ResponseWriter、不能再從Request.Body中讀取資料,不能併發呼叫已完成的ServerHTTP方法
- handler應該先讀取Request.Body,然後再寫ResponseWriter。只要開始向ResponseWriter寫資料後,就不能再從Request.Body中讀取資料
- 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型別中的型別。