在Golang中可将责任链模式与观察者模式结合构建灵活事件处理系统，每个处理器在执行前后通知注册的观察者，实现业务逻辑与日志、监控等副作用解耦。
在 Golang 中将责任链模式（Chain of Responsibility）与观察者模式（Observer Pattern）结合，可以构建灵活、可扩展的事件处理系统。这种复合模式适用于需要按顺序处理请求，并在关键节点通知多个监听者的场景，比如日志处理流水线、审批流程或消息中间件。
责任链与观察者的核心思想
责任链模式让多个对象有机会处理请求，从而避免请求发送者与接收者之间的耦合。请求沿着链条传递，直到某个处理器处理它为止。
观察者模式定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知并自动更新。
将两者结合，可以在每个处理器执行前后广播事件，使外部监听者能够响应处理进度、成功或失败等状态变化。
立即学习“go语言免费学习笔记（深入）”；
实现责任链结构
定义处理器接口，每个处理器持有下一个处理器的引用，并决定是否继续传递请求：
Golang Uber Dig
下载
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
type Request struct {
Data string
Handled bool
}
type Handler interface {
SetNext(handler Handler)
Handle(req *Request)
}
具体处理器实现：
type ConcreteHandler struct {
name string
next Handler
observers []Observer
}
func (h *ConcreteHandler) SetNext(handler Handler) {
h.next = handler
}
func (h *ConcreteHandler) Attach(obs Observer) {
h.observers = append(h.observers, obs)
}
func (h *ConcreteHandler) notify(event string, req *Request) {
for _, obs := range h.observers {
obs.Update(event, req)
}
}
func (h *ConcreteHandler) Handle(req *Request) {
if req.Handled {
return
}
// 处理前通知
h.notify("before_handle", req)
// 模拟处理逻辑
fmt.Printf("Handler %s is processing request: %s\n", h.name, req.Data)
// 标记已处理（可根据业务决定是否继续）
req.Handled = true
// 处理后通知
h.notify("after_handle", req)
// 继续传递（可选：根据条件判断是否传递）
if h.next != nil {
h.next.Handle(req)
}
}
实现观察者机制
定义观察者接口和具体实现：
type Observer interface {
Update(event string, req *Request)
}
type LoggerObserver struct{}
func (l *LoggerObserver) Update(event string, req *Request) {
fmt.Printf("[LOG] Event: %s, Data: %s\n", event, req.Data)
}
type MetricsObserver struct{}
func (m *MetricsObserver) Update(event string, req *Request) {
if event == "after_handle" {
fmt.Println("[METRICS] Increment processing counter")
}
}
组合使用示例
构建链条并注册观察者：
func main() {
handler1 := &ConcreteHandler{name: "Auth"}
handler2 := &ConcreteHandler{name: "Validation"}
handler3 := &ConcreteHandler{name: "Persistence"}
handler1.SetNext(handler2)
handler2.SetNext(handler3)
// 注册观察者到特定处理器
logger := &LoggerObserver{}
metrics := &MetricsObserver{}
handler1.Attach(logger)
handler1.Attach(metrics)
handler2.Attach(logger)
req := &Request{Data: "user registration"}
handler1.Handle(req)
}
输出示例：
[LOG] Event: before_handle, Data: user registration [METRICS] Increment processing counter Handler Auth is processing request: user registration [LOG] Event: after_handle, Data: user registration [LOG] Event: before_handle, Data: user registration Handler Validation is processing request: user registration [LOG] Event: after_handle, Data: user registration Handler Persistence is processing request: user registration
这种设计让系统具备良好的解耦性：处理器专注业务逻辑，观察者负责副作用（如日志、监控），新增处理器或监听者无需修改现有代码。
基本上就这些。关键是明确职责划分，利用接口抽象降低耦合，在合适时机触发通知。不复杂但容易忽略的是控制通知频率和避免循环引用。
