职责链模式(Chain of Responsibility Pattern)
职责链模式是一种行为型设计模式,它通过将请求沿着处理链传递,使得多个对象都有机会来处理请求,从而避免请求发送者和接收者之间的耦合关系。
在 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.”。
推荐文章: