實踐GoF的23種設計模式：裝飾者模式

 // demo/network/socket.go
 package network
 ​
 // 關鍵點1: 定義被裝飾的抽象介面
 // Socket 網路通訊Socket介面
 type Socket interface {
     // Listen 在endpoint指向地址上起監聽
     Listen(endpoint Endpoint) error
     // Close 關閉監聽
     Close(endpoint Endpoint)
     // Send 傳送網路報文
     Send(packet *Packet) error
     // Receive 接收網路報文
     Receive(packet *Packet)
     // AddListener 增加網路報文監聽者
     AddListener(listener SocketListener)
 }
 ​
 // 關鍵點2: 提供一個預設的基礎實現
 type socketImpl struct {
     listener SocketListener
 }
 ​
 func DefaultSocket() *socketImpl {
     return &socketImpl{}
 }
 ​
 func (s *socketImpl) Listen(endpoint Endpoint) error {
     return Instance().Listen(endpoint, s)
 }
 ... // socketImpl的其他Socket實現方法
 ​
 ​
 // demo/sidecar/flowctrl_sidecar.go
 package sidecar
 ​
 // 關鍵點3: 定義裝飾器，實現被裝飾的介面
 // FlowCtrlSidecar HTTP接收端流控功能裝飾器，自動攔截Socket接收報文，實現流控功能
 type FlowCtrlSidecar struct {
   // 關鍵點4: 裝飾器持有被裝飾的抽象介面作為成員屬性
     socket network.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
    }
     // 流控後返回429 Too Many Request響應
     if !f.ctx.TryAccept() {
         httpResp := http.ResponseOfId(httpReq.ReqId()).
             AddStatusCode(http.StatusTooManyRequest).
             AddProblemDetails("enter flow ctrl state")
         f.socket.Send(network.NewPacket(packet.Dest(), packet.Src(), httpResp))
         return
    }
     f.socket.Receive(packet)
 }
 ​
 // 關鍵點6: 不需要擴充套件功能的方法，直接呼叫被裝飾介面的原生方法即可
 func (f *FlowCtrlSidecar) Close(endpoint network.Endpoint) {
     f.socket.Close(endpoint)
 }
 ... // FlowCtrlSidecar的其他方法
 ​
 // 關鍵點7: 定義裝飾器的工廠方法，入參為被裝飾介面
 func NewFlowCtrlSidecar(socket network.Socket) *FlowCtrlSidecar {
     return &FlowCtrlSidecar{
         socket: socket,
         ctx:    flowctrl.NewContext(),
    }
 }
 ​
 // demo/sidecar/all_in_one_sidecar_factory.go
 // 關鍵點8: 使用時，通過裝飾器的工廠方法，把所有裝飾器和被裝飾者串聯起來
 func (a AllInOneFactory) Create() network.Socket {
     return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), a.producer)
 }

 func main() {
   // 註冊/hello的router
     http.HandleFunc("/hello", hello)
   // 啟動http伺服器
     http.ListenAndServe("localhost:8080", nil)
 }
 ​
 // 具體的請求處理邏輯，型別是 http.HandlerFunc
 func hello(w http.ResponseWriter, r *http.Request) {
     w.Write([]byte("hello, world"))
 }

 // demo/network/http/http_handle_func_decorator.go
 ​
 // 關鍵點1: 確定被裝飾介面，這裡為原生的http.HandlerFunc
 type HandlerFunc func(ResponseWriter, *Request)
 ​
 // 關鍵點2: 定義裝飾器型別，是一個函數型別，入參和返回值都是 http.HandlerFunc 函數
 type HttpHandlerFuncDecorator func(http.HandlerFunc) http.HandlerFunc
 ​
 // 關鍵點3: 定義裝飾函數，入參為被裝飾的介面和裝飾器可變列表
 func Decorate(h http.HandlerFunc, decorators ...HttpHandlerFuncDecorator) http.HandlerFunc {
     // 關鍵點4: 通過for迴圈遍歷裝飾器，完成對被裝飾介面的裝飾
     for _, decorator := range decorators {
         h = decorator(h)
    }
     return h
 }
 ​
 // 關鍵點5: 實現具體的裝飾器
 func WithBasicAuth(h http.HandlerFunc) http.HandlerFunc {
     return func(w http.ResponseWriter, r *http.Request) {
         cookie, err := r.Cookie("Auth")
         if err != nil || cookie.Value != "Pass" {
             w.WriteHeader(http.StatusForbidden)
             return
        }
         // 關鍵點6: 完成功能擴充套件之後，呼叫被裝飾的方法，才能將所有裝飾器和被裝飾者串起來
         h(w, r)
    }
 }
 ​
 func WithLogger(h http.HandlerFunc) http.HandlerFunc {
     return func(w http.ResponseWriter, r *http.Request) {
         log.Println(r.Form)
         log.Printf("path %s", r.URL.Path)
         h(w, r)
    }
 }
 ​
 func hello(w http.ResponseWriter, r *http.Request) {
     w.Write([]byte("hello, world"))
 }
 ​
 func main() {
     // 關鍵點7: 通過Decorate函數完成對hello的裝飾
     http.HandleFunc("/hello", Decorate(hello, WithLogger, WithBasicAuth))
     // 啟動http伺服器
     http.ListenAndServe("localhost:8080", nil)
 }

 package context
 ​
 // 被裝飾介面
 type Context interface {
     Deadline() (deadline time.Time, ok bool)
     Done() <-chan struct{}
     Err() error
     Value(key any) any
 }
 ​
 // cancel裝飾器
 type cancelCtx struct {
     Context // 被裝飾介面
     mu       sync.Mutex
     done     atomic.Value
     children map[canceler]struct{}=
     err      error
 }
 // cancel裝飾器的工廠方法
 func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
     // ...  
     c := newCancelCtx(parent)
     propagateCancel(parent, &c)
     return &c, func() { c.cancel(true, Canceled) }
 }
 ​
 // timer裝飾器
 type timerCtx struct {
     cancelCtx // 被裝飾介面
     timer *time.Timer
 ​
     deadline time.Time
 }
 // timer裝飾器的工廠方法
 func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
   // ...
     c := &timerCtx{
         cancelCtx: newCancelCtx(parent),
         deadline:  d,
    }
     // ...
   return c, func() { c.cancel(true, Canceled) }
 }
 // timer裝飾器的工廠方法
 func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
     return WithDeadline(parent, time.Now().Add(timeout))
 }
 ​
 // value裝飾器
 type valueCtx struct {
     Context // 被裝飾介面
     key, val any
 }
 // value裝飾器的工廠方法
 func WithValue(parent Context, key, val any) Context {
     if parent == nil {
         panic("cannot create context from nil parent")
    }
   // ...
     return &valueCtx{parent, key, val}
 }

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