如何使用Golang实现责任链模式与观察者模式结合_Golang模式复合实践-Golang-PHP中文网

如何使用Golang实现责任链模式与观察者模式结合_Golang模式复合实践

P粉602998670

发布： 2025-12-22 16:31:57

原创

259人浏览过

在Golang中可将责任链模式与观察者模式结合构建灵活事件处理系统，每个处理器在执行前后通知注册的观察者，实现业务逻辑与日志、监控等副作用解耦。

如何使用golang实现责任链模式与观察者模式结合_golang模式复合实践

在 Golang 中将责任链模式（Chain of Responsibility）与观察者模式（Observer Pattern）结合，可以构建灵活、可扩展的事件处理系统。这种复合模式适用于需要按顺序处理请求，并在关键节点通知多个监听者的场景，比如日志处理流水线、审批流程或消息中间件。

责任链与观察者的核心思想

责任链模式让多个对象有机会处理请求，从而避免请求发送者与接收者之间的耦合。请求沿着链条传递，直到某个处理器处理它为止。

观察者模式定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知并自动更新。

将两者结合，可以在每个处理器执行前后广播事件，使外部监听者能够响应处理进度、成功或失败等状态变化。

立即学习“go语言免费学习笔记（深入）”；

实现责任链结构

定义处理器接口，每个处理器持有下一个处理器的引用，并决定是否继续传递请求：

type Request struct {
    Data string
    Handled bool
}

type Handler interface {
    SetNext(handler Handler)
    Handle(req *Request)
}

登录后复制

具体处理器实现：

百度AI开放平台

百度提供的综合性AI技术服务平台，汇集了多种AI能力和解决方案

105

查看详情

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

登录后复制

这种设计让系统具备良好的解耦性：处理器专注业务逻辑，观察者负责副作用（如日志、监控），新增处理器或监听者无需修改现有代码。

基本上就这些。关键是明确职责划分，利用接口抽象降低耦合，在合适时机触发通知。不复杂但容易忽略的是控制通知频率和避免循环引用。

以上就是如何使用Golang实现责任链模式与观察者模式结合_Golang模式复合实践的详细内容，更多请关注php中文网其它相关文章！