行为型设计模式—职责链模式

发布时间:2024年01月13日

职责链模式:从名字可以拆分为 职责 和 链。即能为请求创建一条由多个处理器组成的链路,每个处理器各自负责自己的职责,相互之间没有耦合,完成自己任务后请求对象即传递到链路的下一个处理器进行处理。

如果在写好的执行函数里加上部分步骤,导致需要增加若干个if-else,因为整个流程耦合在一起,修改了以后我们就得把整个流程全测一遍。。 而职责链就是把步骤解耦为执行链条,从而消除牵一发而动全身的后果。(链表插入优点是遍历到前节点插入即可,不需要像顺序表一样移动之后所有元素)

在一些核心的业务中,应用职责链模式能够让我们无痛地扩展业务流程的步骤

实现责任链模式的对象最起码需要包含如下特性:

  • 成员属性

    • nextHandler: 下一个等待被调用的对象实例
  • 成员方法

    • SetNext: 把下一个对象的实例绑定到当前对象的nextHandler属性上;
    • Do: 当前对象业务逻辑入口,他是每个处理对象实现自己逻辑的地方;
    • Execute: 负责职责链上请求的处理和传递;它会调用当前对象的DonextHandler不为空则调用nextHandler.Do

SetNextExecute 这两个行为是每个 ConcreteHandler 都一样的,所以这两个可以交给抽象处理类型来实现,每个具体处理对象再继承抽象类型,即可减少重复操作。

以病人去医院看病这个处理流程为例提供一个具体示例。看病的具体流程如下:

挂号—>诊室看病—>收费处缴费—>药房拿药

利用责任链模式,实现这个流程中的每个步骤,且相互间不耦合,还支持向流程中增加步骤。

先实现职责链模式里的公共部分—即模式的接口和抽象类

type PatientHandler interface {
 Execute(*patient) error
 SetNext(PatientHandler) PatientHandler
 Do(*patient) error
}
// 充当抽象类型,实现公共方法,抽象方法不实现留给实现类自己实现
type Next struct {
 nextHandler PatientHandler
}

func (n *Next) SetNext(handler PatientHandler) PatientHandler {
 n.nextHandler = handler
 return handler
}

func (n *Next) Execute(patient *patient) (err error) {
 // 调用不到外部类型的 Do 方法,所以 Next 不能实现 Do 方法
 if n.nextHandler != nil {
  if err = n.nextHandler.Do(patient); err != nil {
   return
  }

  return n.nextHandler.Execute(patient)
 }

 return
}

即使Next实现了Do方法,go语言中语法也不能达到在父类方法中调用子类方法的效果—即在例子里面用Next 类型的Execute方法调用不到外部实现类型的Do方法。

定义职责链要处理的请求,实现处理逻辑和请求传递的DoExecute方法的参数都是流程中要处理的请求。这里是医院接诊的流程,所以定义一个患者类作为流程的请求。

//流程中的请求类--患者
type patient struct {
 Name              string
 RegistrationDone  bool
 DoctorCheckUpDone bool
 MedicineDone      bool
 PaymentDone       bool
}

按照挂号—>诊室看病—>收费处缴费—>药房拿药这个流程定义四个步骤的处理类,来分别实现每个环节的逻辑。

// Reception 挂号处处理器
type Reception struct {
 Next
}

func (r *Reception) Do(p *patient) (err error) {
 if p.RegistrationDone {
  fmt.Println("Patient registration already done")
  return
 }
 fmt.Println("Reception registering patient")
 p.RegistrationDone = true
 return
}

// Clinic 诊室处理器--用于医生给病人看病
type Clinic struct {
 Next
}

func (d *Clinic) Do(p *patient) (err error) {
 if p.DoctorCheckUpDone {
  fmt.Println("Doctor checkup already done")
  return
 }
 fmt.Println("Doctor checking patient")
 p.DoctorCheckUpDone = true
 return
}

// Cashier 收费处处理器
type Cashier struct {
 Next
}

func (c *Cashier) Do(p *patient) (err error) {
 if p.PaymentDone {
  fmt.Println("Payment Done")
  return
 }
 fmt.Println("Cashier getting money from patient patient")
 p.PaymentDone = true
 return
}

// Pharmacy 药房处理器
type Pharmacy struct {
 Next
}


func (m *Pharmacy) Do (p *patient) (err error) {
 if p.MedicineDone {
  fmt.Println("Medicine already given to patient")
  return
 }
 fmt.Println("Pharmacy giving medicine to patient")
 p.MedicineDone = true
 return
}

Recepiton接诊挂号这个步骤提供的逻辑没有调用到,再定义StartHandler 类型,它不提供处理实现只是作为第一个Handler向下转发请求

// StartHandler 不做操作,作为第一个Handler向下转发请求
type StartHandler struct {
 Next
}

// Do 空Handler的Do
func (h *StartHandler) Do(c *patient) (err error) {
 // 空Handler 这里什么也不做 只是载体 do nothing...
 return
}

这是Go 语法限制,公共方法Exeute并不能像面向对象那样先调用this.Do 再调用this.nextHandler.Do

把处理类串起来执行

func main() {
 patientHealthHandler := StartHandler{}
 //
 patient := &patient{Name: "abc"}
 // 设置病人看病的链路
 patientHealthHandler.SetNext(&Reception{}).// 挂号
  SetNext(&Clinic{}). // 诊室看病
  SetNext(&Cashier{}). // 收费处交钱
  SetNext(&Pharmacy{}) // 药房拿药
 //还可以扩展,比如中间加入化验科化验,图像科拍片等等

 // 执行上面设置好的业务流程
 if err := patientHealthHandler.Execute(patient); err != nil {
  // 异常
  fmt.Println("Fail | Error:" + err.Error())
  return
 }
 // 成功
 fmt.Println("Success")
}

职责链也可以设置中止条件,针对例子就是在Execute方法里加判断,一旦满足中止后就不再继续往链路的下级节点传递请求。

这也是职责链跟装饰器模式的一个区别,装饰器模式无法在增强实体的过程中停止,只能执行完整个装饰链路。

针对那些可能未来经常会变的核心业务流程,可以在设计初期就考虑使用职责链来实现,减轻未来流程不停迭代时不好扩展的痛点。

职责链模式与模板模式的区别在于,模板模式的业务流程通常是规定不变的,而职责链模式业务是可拓展的

文章来源:https://blog.csdn.net/zhaicheng55/article/details/135566002
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。