Go語言常見設計模式之裝飾模式詳解

更新時間：2023年07月05日 11:05:35 作者：江湖十年

在?Go?語言中，雖然裝飾模式沒有像?Python?中應用那么廣泛，但也有其用武之地，這篇文章我們就來一起看下裝飾模式在?Go?語言中的應用吧

熟悉 Python 的同學想必對裝飾模式都不會太陌生，Python 從語法上原生支持裝飾器，大大提高了裝飾模式在 Python 中的應用。而在 Go 語言中，雖然裝飾模式沒有像 Python 中應用那么廣泛，但也有其用武之地，這篇文章我們就來一起看下裝飾模式在 Go 語言中的應用。

簡單裝飾器

首先我們編寫一個簡單的 hello 函數：

package main
import "fmt"
func hello() {
	fmt.Println("Hello World!")
}
func main() {
	hello()
}

上面代碼執(zhí)行后輸出 Hello World!。

現(xiàn)在我們想在打印 Hello World! 前后各加一行日志，最直接的實現(xiàn)方式如下：

package main
import "fmt"
func hello() {
	fmt.Println("before")
	fmt.Println("Hello World!")
	fmt.Println("after")
}
func main() {
	hello()
}

代碼執(zhí)行后輸出：

before
Hello World!
after

更好的實現(xiàn)方式是單獨編寫一個 logger 函數，專門用來打印日志：

package main
import "fmt"
func logger(f func()) func() {
	return func() {
		fmt.Println("before")
		f()
		fmt.Println("after")
	}
}
func hello() {
	fmt.Println("Hello World!")
}
func main() {
	hello := logger(hello)
	hello()
}

logger 函數接收一個函數，并且返回一個函數，而且參數和返回值的函數簽名同 hello 函數一樣。我們將原來調用 hello() 的地方改成：

hello := logger(hello)
hello()

就實現(xiàn)了 logger 函數對 hello 函數的包裝，執(zhí)行后的打印結果仍為：

before
Hello World!
after

這樣我們就以一種更加優(yōu)雅的方式，實現(xiàn)了給 hello 函數增加日志的功能，因為這個 logger 函數不僅可以用于 hello，還可以用于其他任何與 hello 函數有著同樣簽名的函數。

logger 函數也就是我們在 Python 中經常使用的裝飾器，如果按照 Python 中裝飾器的寫法，我們可以這樣做：

package main
import "fmt"
func logger(f func()) func() {
	return func() {
		fmt.Println("before")
		f()
		fmt.Println("after")
	}
}
// 給 hello 函數打上 logger 裝飾器
@logger
func hello() {
	fmt.Println("Hello World!")
}
func main() {
	// hello 函數調用方式不變
	hello()
}

但很遺憾，上面的程序無法通過編譯，Go 語言目前還沒有像 Python 語言一樣從語法層面提供對裝飾器語法糖的支持。

裝飾器實現(xiàn)中間件

盡管 Go 語言中裝飾器的寫法不如 Python 語言精簡，但有一個場景的確非常適用，那就是 Web 開發(fā)場景中的中間件組件。

如果你用過 Gin Web 框架，那么應該很容易能看懂如下代碼：

package main
import "github.com/gin-gonic/gin"
func main() {
	r := gin.New()
	// 使用中間件
	r.Use(gin.Logger(), gin.Recovery())
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "pong",
		})
	})
	_ = r.Run(":8888")
}

在 Gin 框架中可以通過 r.Use(middlewares...) 的方式給路由增加非常多的中間件，這樣我們就能夠很方便的攔截路由處理函數，并在其前后分別做一些處理邏輯。如上面示例中使用 gin.Logger() 增加日志，使用 gin.Recovery() 來處理 panic 異常。

Gin 框架的中間件正是使用裝飾模式來實現(xiàn)的，我們可以借用 Go 語言自帶的 http 庫來簡單模擬下：

package main
import (
	"fmt"
	"net/http"
)
func loggerMiddleware(f http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		fmt.Println("before")
		f(w, r)
		fmt.Println("after")
	}
}
func authMiddleware(f http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if token := r.Header.Get("token"); token != "fake_token" {
			_, _ = w.Write([]byte("unauthorized\n"))
			return
		}
		f(w, r)
	}
}
func handleHello(w http.ResponseWriter, r *http.Request) {
	fmt.Println("handle hello")
	_, _ = w.Write([]byte("Hello World!\n"))
}
func main() {
	http.HandleFunc("/hello", authMiddleware(loggerMiddleware(handleHello)))
	fmt.Println(http.ListenAndServe(":8888", nil))
}

這是一個簡單的 Web Server 程序，其監(jiān)聽 8888 端口，當訪問 /hello 路由時會進入 handleHello 函數邏輯。

我們分別使用 loggerMiddleware、authMiddleware 函數對 handleHello 進行了包裝，使其支持打印訪問日志和認證校驗功能。假如我們還有其他中間件攔截功能需要加入，就可以這么無限包裝下去。

啟動這個 Server 來驗證下裝飾器：

可以對結果進行簡單分析，第一次請求 /hello 接口時，由于沒有攜帶認證 token，收到了 unauthorized 響應；第二次請求時攜帶了 token，得到響應 Hello World!，并且后臺程序打印如下日志：

before
handle hello
after

說明中間件執(zhí)行順序是先由外向內進入，再由內向外返回。而這種一層一層包裝處理邏輯的模型有一個非常形象的名字，叫作洋蔥模型。

這個名字可以說非常貼切了。但我們用洋蔥模型實現(xiàn)的中間件，相比于 Gin 框架的中間件寫法上還差點意思，這種一層層包裹函數的寫法不如 Gin 框架提供的 r.Use(middlewares...) 寫法直觀。

如果你去看 Gin 框架源碼，就會發(fā)現(xiàn)它的中間件和 handler 處理函數實際上會被一起聚合到路由節(jié)點的 handlers 屬性中，而這個 handlers 屬性其實就是一個 HandlerFunc 類型切片。對應到咱們用 http 標準庫實現(xiàn)的 Web Server 中，就是滿足 func(ResponseWriter, *Request) 類型的 handler 切片。當路由接口被調用時，Gin 框架就會依次執(zhí)行 handlers 切片中的所有函數，整個中間件的調用流程就像一條流水線一樣依次調用，再依次返回。而這種思想也有一個形象的名字，叫作流水線（Pipeline）。

接下來我們要做的就是將 handleHello 和兩個中間件 loggerMiddleware、authMiddleware 聚合到一起，同樣形成一個 Pipeline。

package main
import (
	"fmt"
	"net/http"
)
func authMiddleware(f http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if token := r.Header.Get("token"); token != "fake_token" {
			_, _ = w.Write([]byte("unauthorized\n"))
			return
		}
		f(w, r)
	}
}
func loggerMiddleware(f http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		fmt.Println("before")
		f(w, r)
		fmt.Println("after")
	}
}
type handler func(http.HandlerFunc) http.HandlerFunc
// 聚合 handler 和 middleware
func pipelineHandlers(h http.HandlerFunc, hs ...handler) http.HandlerFunc {
	for i := range hs {
		h = hs[i](h)
	}
	return h
}
func handleHello(w http.ResponseWriter, r *http.Request) {
	fmt.Println("handle hello")
	_, _ = w.Write([]byte("Hello World!\n"))
}
func main() {
	http.HandleFunc("/hello", pipelineHandlers(handleHello, loggerMiddleware, authMiddleware))
	fmt.Println(http.ListenAndServe(":8888", nil))
}

我們借用 pipelineHandlers 函數將 handler 和 middleware 聚合到一起，實現(xiàn)了讓這個簡單的 Web Server 中間件用法跟 Gin 框架用法相似的效果。

再次啟動 Server 進行驗證：

改造成功，跟之前使用洋蔥模型寫法的結果如出一轍。

總結

在簡單介紹了 Go 語言中如何實現(xiàn)裝飾模式后，我們通過對一個 Web Server 程序中間件的講解，學習了裝飾模式在 Go 語言中的應用。因為 Go 語言是靜態(tài)類型語言，不像 Python 那般靈活，所以在實現(xiàn)上要多費一點力氣，并且 Go 語言實現(xiàn)的裝飾器由于有類型上的限制，也不如 Python 裝飾器那般通用，但仍有用武之地。

盡管我們最終實現(xiàn)的 pipelineHandlers 不如 Gin 框架中間件強大，比如不能延遲調用，通過 c.Next() 控制中間件調用流等，但通過這個簡單的示例，相信對你接下來深入學習 Gin 框架會有所幫助。

以上就是Go語言常見設計模式之裝飾模式詳解的詳細內容，更多關于Go裝飾模式的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: