实践 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")
}复制