溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“Go語言的Handler有什么用”，在日常操作中，相信很多人在Go語言的Handler有什么用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Go語言的Handler有什么用”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
Multiplexer根據URL將請求路由給指定的Handler。Handler用于處理請求并給予響應。更嚴格地說，用來讀取請求體、并將請求對應的響應字段(respones header)寫入ResponseWriter中，然后返回。
什么是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接口的定義：
// 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和響應數據通過網絡鏈接發送給客戶端。
在啟動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，一個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()
}下面是訪問的結果：
除了使用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()是函數，用來給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是用來處理http請求的，處理過程可能會很簡單，也可能會很復雜。復雜的情況下，可能無法使用一個單獨的handler來完成工作，畢竟handler只是一個函數。盡管我們可以直接在這個函數中調用其它函數。
很經常地，可能handler中需要嵌套其它handler，甚至多層嵌套，這就是鏈式handler。
由于Handle()或HandleFunc()注冊的時候需要指定參數類型，所以handler嵌套的時候，也要關注handler的參數類型以及返回類型。看下面示例就會明白參數類型和返回類型是怎么要求的。
代碼如下：
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嵌套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類型中的類型。
到此，關于“Go語言的Handler有什么用”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
