上一篇：【Go實現】實踐GoF的23種設計模式：原型模式

簡單的分布式應用系統（示例代碼工程）：https://github.com/ruanrunxue/Practice-Design-Pattern--Go-Implementation

簡介

我們經常會遇到“給現有對象/模塊新增功能”的場景，比如 http router 的開發場景下，除了最基礎的路由功能之外，我們常常還會加上如日志、鑒權、流控等 middleware。如果你查看框架的源碼，就會發現 middleware 功能的實現用的就是裝飾者模式（Decorator Pattern）。

GoF給裝飾者模式的定義如下：

Decorators provide a flexible alternative to subclassing for extending functionality. Attach additional responsibilities to an object dynamically.

簡單來說，裝飾者模式通過組合的方式，提供了能夠動態地給對象/模塊擴展新功能的能力。理論上，只要沒有限制，它可以一直把功能疊加下去，具有很高的靈活性。

如果寫過 Java，那么一定對 I/O Stream 體系不陌生，它是裝飾者模式的經典用法，客戶端程序可以動態地為原始的輸入輸出流添加功能，比如按字符串輸入輸出，加入緩沖等，使得整個 I/O Stream 體系具有很高的可擴展性和靈活性。

UML 結構

場景上下文

在簡單的分布式應用系統（示例代碼工程）中，我們設計了 Sidecar 邊車模塊，它的用處主要是為了 1）方便擴展network.Socket的功能，如增加日志、流控等非業務功能；2）讓這些附加功能對業務程序隱藏起來，也即業務程序只須關心看到network.Socket接口即可。

代碼實現

Sidecar 的這個功能場景，很適合使用裝飾者模式來實現，代碼如下：

//demo/network/socket.go
packagenetwork

//關鍵點1:定義被裝飾的抽象接口
//Socket網絡通信Socket接口
typeSocketinterface{
//Listen在endpoint指向地址上起監聽
Listen(endpointEndpoint)error
//Close關閉監聽
Close(endpointEndpoint)
//Send發送網絡報文
Send(packet*Packet)error
//Receive接收網絡報文
Receive(packet*Packet)
//AddListener增加網絡報文監聽者
AddListener(listenerSocketListener)
}

//關鍵點2:提供一個默認的基礎實現
typesocketImplstruct{
listenerSocketListener
}

funcDefaultSocket()*socketImpl{
return&socketImpl{}
}

func(s*socketImpl)Listen(endpointEndpoint)error{
returnInstance().Listen(endpoint,s)
}
...//socketImpl的其他Socket實現方法


//demo/sidecar/flowctrl_sidecar.go
packagesidecar

//關鍵點3:定義裝飾器，實現被裝飾的接口
//FlowCtrlSidecarHTTP接收端流控功能裝飾器，自動攔截Socket接收報文，實現流控功能
typeFlowCtrlSidecarstruct{
//關鍵點4:裝飾器持有被裝飾的抽象接口作為成員屬性
socketnetwork.Socket
ctx*flowctrl.Context
}

//關鍵點5:對于需要擴展功能的方法，新增擴展功能
func(f*FlowCtrlSidecar)Receive(packet*network.Packet){
httpReq,ok:=packet.Payload().(*http.Request)
//如果不是HTTP請求，則不做流控處理
if!ok{
f.socket.Receive(packet)
return
}
//流控后返回429TooManyRequest響應
if!f.ctx.TryAccept(){
httpResp:=http.ResponseOfId(httpReq.ReqId()).
AddStatusCode(http.StatusTooManyRequest).
AddProblemDetails("enterflowctrlstate")
f.socket.Send(network.NewPacket(packet.Dest(),packet.Src(),httpResp))
return
}
f.socket.Receive(packet)
}

//關鍵點6:不需要擴展功能的方法，直接調用被裝飾接口的原生方法即可
func(f*FlowCtrlSidecar)Close(endpointnetwork.Endpoint){
f.socket.Close(endpoint)
}
...//FlowCtrlSidecar的其他方法

//關鍵點7:定義裝飾器的工廠方法，入參為被裝飾接口
funcNewFlowCtrlSidecar(socketnetwork.Socket)*FlowCtrlSidecar{
return&FlowCtrlSidecar{
socket:socket,
ctx:flowctrl.NewContext(),
}
}

//demo/sidecar/all_in_one_sidecar_factory.go
//關鍵點8:使用時，通過裝飾器的工廠方法，把所有裝飾器和被裝飾者串聯起來
func(aAllInOneFactory)Create()network.Socket{
returnNewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()),a.producer)
}

總結實現裝飾者模式的幾個關鍵點：

1. 定義需要被裝飾的抽象接口，后續的裝飾器都是基于該接口進行擴展。
2. 為抽象接口提供一個基礎實現。
3. 定義裝飾器，并實現被裝飾的抽象接口。
4. 裝飾器持有被裝飾的抽象接口作為成員屬性。“裝飾”的意思是在原有功能的基礎上擴展新功能，因此必須持有原有功能的抽象接口。
5. 在裝飾器中，對于需要擴展功能的方法，新增擴展功能。
6. 不需要擴展功能的方法，直接調用被裝飾接口的原生方法即可。
7. 為裝飾器定義一個工廠方法，入參為被裝飾接口。
8. 使用時，通過裝飾器的工廠方法，把所有裝飾器和被裝飾者串聯起來。

擴展

Go 風格的實現

在 Sidecar 的場景上下文中，被裝飾的Socket是一個相對復雜的接口，裝飾器通過實現Socket接口來進行功能擴展，是典型的面向對象風格。

如果被裝飾者是一個簡單的接口/方法/函數，我們可以用更具 Go 風格的實現方式，考慮前文提到的 http router 場景。如果你使用原生的net/http進行 http router 開發，通常會這么實現：

funcmain(){
//注冊/hello的router
http.HandleFunc("/hello",hello)
//啟動http服務器
http.ListenAndServe("localhost:8080",nil)
}

//具體的請求處理邏輯，類型是http.HandlerFunc
funchello(whttp.ResponseWriter,r*http.Request){
w.Write([]byte("hello,world"))
}

其中，我們通過http.HandleFunc來注冊具體的 router，hello是具體的請求處理方法。現在，我們想為該 http 服務器增加日志、鑒權等通用功能，那么可以把func(w http.ResponseWriter, r *http.Request)作為被裝飾的抽象接口，通過新增日志、鑒權等裝飾器完成功能擴展。

//demo/network/http/http_handle_func_decorator.go

//關鍵點1:確定被裝飾接口，這里為原生的http.HandlerFunc
typeHandlerFuncfunc(ResponseWriter,*Request)

//關鍵點2:定義裝飾器類型，是一個函數類型，入參和返回值都是http.HandlerFunc函數
typeHttpHandlerFuncDecoratorfunc(http.HandlerFunc)http.HandlerFunc

//關鍵點3:定義裝飾函數，入參為被裝飾的接口和裝飾器可變列表
funcDecorate(hhttp.HandlerFunc,decorators...HttpHandlerFuncDecorator)http.HandlerFunc{
//關鍵點4:通過for循環遍歷裝飾器，完成對被裝飾接口的裝飾
for_,decorator:=rangedecorators{
h=decorator(h)
}
returnh
}

//關鍵點5:實現具體的裝飾器
funcWithBasicAuth(hhttp.HandlerFunc)http.HandlerFunc{
returnfunc(whttp.ResponseWriter,r*http.Request){
cookie,err:=r.Cookie("Auth")
iferr!=nil||cookie.Value!="Pass"{
w.WriteHeader(http.StatusForbidden)
return
}
//關鍵點6:完成功能擴展之后，調用被裝飾的方法，才能將所有裝飾器和被裝飾者串起來
h(w,r)
}
}

funcWithLogger(hhttp.HandlerFunc)http.HandlerFunc{
returnfunc(whttp.ResponseWriter,r*http.Request){
log.Println(r.Form)
log.Printf("path%s",r.URL.Path)
h(w,r)
}
}

funchello(whttp.ResponseWriter,r*http.Request){
w.Write([]byte("hello,world"))
}

funcmain(){
//關鍵點7:通過Decorate函數完成對hello的裝飾
http.HandleFunc("/hello",Decorate(hello,WithLogger,WithBasicAuth))
//啟動http服務器
http.ListenAndServe("localhost:8080",nil)
}

上述的裝飾者模式的實現，用到了類似于Functional Options的技巧，也是巧妙利用了 Go 的函數式編程的特點，總結下來有如下幾個關鍵點：

1. 確定被裝飾的接口，上述例子為http.HandlerFunc。
2. 定義裝飾器類型，是一個函數類型，入參和返回值都是被裝飾接口，上述例子為func(http.HandlerFunc) http.HandlerFunc。
3. 定義裝飾函數，入參為被裝飾的接口和裝飾器可變列表，上述例子為Decorate方法。
4. 在裝飾方法中，通過for循環遍歷裝飾器，完成對被裝飾接口的裝飾。這里是用來類似Functional Options的技巧，一定要注意裝飾器的順序！
5. 實現具體的裝飾器，上述例子為WithBasicAuth和WithLogger函數。
6. 在裝飾器中，完成功能擴展之后，記得調用被裝飾者的接口，這樣才能將所有裝飾器和被裝飾者串起來。
7. 在使用時，通過裝飾函數完成對被裝飾者的裝飾，上述例子為Decorate(hello, WithLogger, WithBasicAuth)。

Go 標準庫中的裝飾者模式

在 Go 標準庫中，也有一個運用了裝飾者模式的模塊，就是context，其中關鍵的接口如下：

packagecontext

//被裝飾接口
typeContextinterface{
Deadline()(deadlinetime.Time,okbool)
Done()<-chanstruct{}
Err()error
Value(keyany)any
}

//cancel裝飾器
typecancelCtxstruct{
Context//被裝飾接口
musync.Mutex
doneatomic.Value
childrenmap[canceler]struct{}=
errerror
}
//cancel裝飾器的工廠方法
funcWithCancel(parentContext)(ctxContext,cancelCancelFunc){
//...
c:=newCancelCtx(parent)
propagateCancel(parent,&c)
return&c,func(){c.cancel(true,Canceled)}
}

//timer裝飾器
typetimerCtxstruct{
cancelCtx//被裝飾接口
timer*time.Timer

deadlinetime.Time
}
//timer裝飾器的工廠方法
funcWithDeadline(parentContext,dtime.Time)(Context,CancelFunc){
//...
c:=&timerCtx{
cancelCtx:newCancelCtx(parent),
deadline:d,
}
//...
returnc,func(){c.cancel(true,Canceled)}
}
//timer裝飾器的工廠方法
funcWithTimeout(parentContext,timeouttime.Duration)(Context,CancelFunc){
returnWithDeadline(parent,time.Now().Add(timeout))
}

//value裝飾器
typevalueCtxstruct{
Context//被裝飾接口
key,valany
}
//value裝飾器的工廠方法
funcWithValue(parentContext,key,valany)Context{
ifparent==nil{
panic("cannotcreatecontextfromnilparent")
}
//...
return&valueCtx{parent,key,val}
}

使用時，可以這樣：

//使用時，可以這樣
funcmain(){
ctx:=context.Background()
ctx=context.WithValue(ctx,"key1","value1")
ctx,_=context.WithTimeout(ctx,time.Duration(1))
ctx=context.WithValue(ctx,"key2","value2")
}

不管是 UML 結構，還是使用方法，context模塊都與傳統的裝飾者模式有一定出入，但也不妨礙context是裝飾者模式的典型運用。還是那句話，學習設計模式，不能只記住它的結構，而是學習其中的動機和原理。

典型使用場景

• I/O 流，比如為原始的 I/O 流增加緩沖、壓縮等功能。
• Http Router，比如為基礎的 Http Router 能力增加日志、鑒權、Cookie等功能。
• ......

優缺點

優點

1. 遵循開閉原則，能夠在不修改老代碼的情況下擴展新功能。
2. 可以用多個裝飾器把多個功能組合起來，理論上可以無限組合。

缺點

1. 一定要注意裝飾器裝飾的順序，否則容易出現不在預期內的行為。
2. 當裝飾器越來越多之后，系統也會變得復雜。

與其他模式的關聯

裝飾者模式和代理模式具有很高的相似性，但是兩種所強調的點不一樣。前者強調的是為本體對象添加新的功能；后者強調的是對本體對象的訪問控制。

裝飾者模式和適配器模式的區別是，前者只會擴展功能而不會修改接口；后者則會修改接口。

文章配圖

可以在用Keynote畫出手繪風格的配圖中找到文章的繪圖方法。

審核編輯 ：李倩