method 覆盖

code

责任链模式是一种行为设计模式，它允许将请求沿着处理者链传递，直到有处理者处理它。每个处理者都包含指向下一个处理者的引用。

责任链模式的关键点

• 处理者链: 每个处理者知道下一个处理者，可以将请求传递下去。
• 请求处理: 每个处理者可以选择处理请求或将其传递给下一个处理者。
• 解耦: 客户端不需要知道链的结构或请求的处理者。

责任链模式的实现

以下是一个简单的 Go 语言实现：

package main

import "fmt"

// Handler 是处理请求的接口
type Handler interface {
    SetNext(handler Handler)
    Handle(request string)
}

// BaseHandler 提供了默认的 SetNext 实现
type BaseHandler struct {
    next Handler
}

func (h *BaseHandler) SetNext(handler Handler) {
    h.next = handler
}

func (h *BaseHandler) Handle(request string) {
    if h.next != nil {
        h.next.Handle(request)
    }
}

// ConcreteHandlerA 是具体的处理者
type ConcreteHandlerA struct {
    BaseHandler
}

func (h *ConcreteHandlerA) Handle(request string) { // 覆盖 BaseHandler的 Handle 方法
    if request == "A" {
        fmt.Println("Handled by ConcreteHandlerA")
    } else {
        fmt.Println("ConcreteHandlerA can't handle, passing to next")
        h.BaseHandler.Handle(request)
    }
}

// ConcreteHandlerB 是另一个具体的处理者
type ConcreteHandlerB struct {
    BaseHandler
}

func (h *ConcreteHandlerB) Handle(request string) { // 覆盖 BaseHandler的 Handle 方法
    if request == "B" {
        fmt.Println("Handled by ConcreteHandlerB")
    } else {
        fmt.Println("ConcreteHandlerB can't handle, passing to next")
        h.BaseHandler.Handle(request)
    }
}

func main() {
    handlerA := &ConcreteHandlerA{}
    handlerB := &ConcreteHandlerB{}

    handlerA.SetNext(handlerB)

    handlerA.Handle("A")
    fmt.Println(">>>>")
    handlerA.Handle("B")
    fmt.Println(">>>>")
    handlerA.Handle("C")
}


// 输出：
// Handled by ConcreteHandlerA
// >>>>
// ConcreteHandlerA can't handle, passing to next
// Handled by ConcreteHandlerB
// >>>>
// ConcreteHandlerA can't handle, passing to next
// ConcreteHandlerB can't handle, passing to next

关键点

• 链的创建: 通过 SetNext 方法构建处理者链。
• 请求传递: 每个处理者尝试处理请求，如果不能处理则传递给下一个。

这种模式非常适合需要多个对象以某种顺序处理请求的情况。它提供了一种灵活的方式来处理请求，并且可以很容易地添加或修改处理者而不影响客户端代码。