职责链模式（Chain of Responsibility Pattern）

1.0.0

1.0.0

职责链模式是一种行为型设计模式，它通过将请求沿着处理链传递，使得多个对象都有机会来处理请求，从而避免请求发送者和接收者之间的耦合关系。

在 Go 语言中，可以使用接口和结构体来实现职责链模式。

首先，定义一个处理请求的接口：

type Handler interface {
    SetNext(handler Handler)
    HandleRequest(request string)
}

接口中定义了 SetNext() 方法和 HandleRequest() 方法。SetNext() 方法用于设置下一个处理请求的处理器，而 HandleRequest() 方法用于处理请求。

接着，定义一个基础处理器结构体：

type BaseHandler struct {
    nextHandler Handler
}

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

基础处理器结构体中包含了下一个处理请求的处理器，并实现了 SetNext() 方法。

然后，定义多个具体处理请求的处理器结构体，它们都继承自基础处理器结构体：

type ConcreteHandlerA struct{
    BaseHandler
}

func (h *ConcreteHandlerA) HandleRequest(request string) {
    if request == "A" {
        fmt.Println("ConcreteHandlerA handled the request.")
    } else if h.nextHandler != nil {
        h.nextHandler.HandleRequest(request)
    } else {
        fmt.Println("No handler can handle the request.")
    }
}

type ConcreteHandlerB struct{
    BaseHandler
}

func (h *ConcreteHandlerB) HandleRequest(request string) {
    if request == "B" {
        fmt.Println("ConcreteHandlerB handled the request.")
    } else if h.nextHandler != nil {
        h.nextHandler.HandleRequest(request)
    } else {
        fmt.Println("No handler can handle the request.")
    }
}

具体处理器结构体中实现了 HandleRequest() 方法，用于处理具体的请求。如果当前处理器无法处理该请求，则将请求传递给下一个处理器。如果下一个处理器不存在，则表示没有处理器能够处理该请求。

最后，定义一个客户端程序来使用职责链模式：

package main

import "fmt"

// Handler 接口
type Handler interface {
    SetNext(handler Handler)
    HandleRequest(request string)
}

// BaseHandler 结构体
type BaseHandler struct {
    nextHandler Handler
}

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

// ConcreteHandlerA 结构体
type ConcreteHandlerA struct{
    BaseHandler
}

func (h *ConcreteHandlerA) HandleRequest(request string) {
    if request == "A" {
        fmt.Println("ConcreteHandlerA handled the request.")
    } else if h.nextHandler != nil {
        h.nextHandler.HandleRequest(request)
    } else {
        fmt.Println("No handler can handle the request.")
    }
}

// ConcreteHandlerB struct
type ConcreteHandlerB struct{
    BaseHandler
}

func (h *ConcreteHandlerB) HandleRequest(request string) {
    if request == "B" {
        fmt.Println("ConcreteHandlerB handled the request.")
    } else if h.nextHandler != nil {
        h.nextHandler.HandleRequest(request)
    } else {
        fmt.Println("No handler can handle the request.")
    }
}

func main() {
    concreteHandlerA := &ConcreteHandlerA{}
    concreteHandlerB := &ConcreteHandlerB{}
    concreteHandlerA.SetNext(concreteHandlerB)

    concreteHandlerA.HandleRequest("A")
    concreteHandlerA.HandleRequest("B")
    concreteHandlerA.HandleRequest("C")
}

在这个示例代码中，首先创建了两个具体处理请求的处理器结构体 ConcreteHandlerA 和 ConcreteHandlerB。然后将它们通过 SetNext() 方法设置为处理请求的处理链。最后执行 HandleRequest() 方法，将请求 “A”、”B” 和 “C” 依次传递给处理链进行处理。

执行结果如下：

ConcreteHandlerA handled the request.
ConcreteHandlerB handled the request.
No handler can handle the request.

在这个示例代码中，请求 “A” 首先被 ConcreteHandlerA 处理，输出 “ConcreteHandlerA handled the request.”。请求 “B” 首先被 ConcreteHandlerA 处理，但是由于请求 “B” 是 ConcreteHandlerB 处理的请求，因此 ConcreteHandlerA 将请求传递给下一个处理器 ConcreteHandlerB 进行处理，输出 “ConcreteHandlerB handled the request.”。请求 “C” 首先被 ConcreteHandlerA 处理，由于 ConcreteHandlerA 和 ConcreteHandlerB 都无法处理请求 “C”，因此输出 “No handler can handle the request.”。