责任链模式
约 442 字大约 1 分钟
2025-12-27
定义
使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
责任链模式的优点
责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性。
责任链模式的缺点
责任链模式有两个显著的缺点：一是性能问题，每个请求都是从链头便利到链尾，特别是链比较长的时候，性能是一个非常大的问题。二是调试不很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。
示例
package main
import "fmt"
// Handler 接口
type Handler interface {
Handle(request string) bool
SetNext(handler Handler)
}
// BaseHandler 基类
type BaseHandler struct {
next Handler
}
func (b *BaseHandler) SetNext(handler Handler) {
b.next = handler
}
func (b *BaseHandler) PassNext(request string) bool {
if b.next != nil {
return b.next.Handle(request)
}
return false
}
// HandlerA
type HandlerA struct {
BaseHandler
}
func (h *HandlerA) Handle(request string) bool {
if request == "A" {
fmt.Println("HandlerA 处理了请求:", request)
return true
}
return h.PassNext(request)
}
// HandlerB
type HandlerB struct {
BaseHandler
}
func (h *HandlerB) Handle(request string) bool {
if request == "B" {
fmt.Println("HandlerB 处理了请求:", request)
return true
}
return h.PassNext(request)
}
// HandlerC
type HandlerC struct {
BaseHandler
}
func (h *HandlerC) Handle(request string) bool {
if request == "C" {
fmt.Println("HandlerC 处理了请求:", request)
return true
}
return h.PassNext(request)
}
func main() {
h1 := &HandlerA{}
h2 := &HandlerB{}
h3 := &HandlerC{}
h1.SetNext(h2)
h2.SetNext(h3)
requests := []string{"A", "B", "C", "D"}
for _, r := range requests {
if !h1.Handle(r) {
fmt.Println("没有处理者处理请求:", r)
}
}
}