职责链模式

10.1 模式动机

职责链模式用于分离不同职责，并且动态组合相关职责。

Golang实现职责链模式时候，因为没有继承的支持，使用链对象包涵职责的方式，即：

  • 链对象包含当前职责对象以及下一个职责链。
  • 职责对象提供接口表示是否能处理对应请求。
  • 职责对象提供处理函数处理相关职责。

同时可在职责链类中实现职责接口相关函数，使职责链对象可以当做一般职责对象是用。

10.2 Go语言实现

chain.go

  1. package chain
  3. import "fmt"
  5. type Manager interface {
  6.     HaveRight(money int) bool
  7.     HandleFeeRequest(name string, money int) bool
  8. }
  10. type RequestChain struct {
  11.     Manager
  12.     successor *RequestChain
  13. }
  15. func (r *RequestChain) SetSuccessor(m *RequestChain) {
  16.     r.successor = m
  17. }
  19. func (r *RequestChain) HandleFeeRequest(name string, money int) bool {
  20.     if r.Manager.HaveRight(money) {
  21.         return r.Manager.HandleFeeRequest(name, money)
  22.     }
  23.     if r.successor != nil {
  24.         return r.successor.HandleFeeRequest(name, money)
  25.     }
  26.     return false
  27. }
  29. func (r *RequestChain) HaveRight(money int) bool {
  30.     return true
  31. }
  33. type ProjectManager struct{}
  35. func NewProjectManagerChain() *RequestChain {
  36.     return &RequestChain{
  37.         Manager: &ProjectManager{},
  38.     }
  39. }
  41. func (*ProjectManager) HaveRight(money int) bool {
  42.     return money < 500
  43. }
  45. func (*ProjectManager) HandleFeeRequest(name string, money int) bool {
  46.     if name == "bob" {
  47.         fmt.Printf("Project manager permit %s %d fee request\n", name, money)
  48.         return true
  49.     }
  50.     fmt.Printf("Project manager don't permit %s %d fee request\n", name, money)
  51.     return false
  52. }
  54. type DepManager struct{}
  56. func NewDepManagerChain() *RequestChain {
  57.     return &RequestChain{
  58.         Manager: &DepManager{},
  59.     }
  60. }
  62. func (*DepManager) HaveRight(money int) bool {
  63.     return money < 5000
  64. }
  66. func (*DepManager) HandleFeeRequest(name string, money int) bool {
  67.     if name == "tom" {
  68.         fmt.Printf("Dep manager permit %s %d fee request\n", name, money)
  69.         return true
  70.     }
  71.     fmt.Printf("Dep manager don't permit %s %d fee request\n", name, money)
  72.     return false
  73. }
  75. type GeneralManager struct{}
  77. func NewGeneralManagerChain() *RequestChain {
  78.     return &RequestChain{
  79.         Manager: &GeneralManager{},
  80.     }
  81. }
  83. func (*GeneralManager) HaveRight(money int) bool {
  84.     return true
  85. }
  87. func (*GeneralManager) HandleFeeRequest(name string, money int) bool {
  88.     if name == "ada" {
  89.         fmt.Printf("General manager permit %s %d fee request\n", name, money)
  90.         return true
  91.     }
  92.     fmt.Printf("General manager don't permit %s %d fee request\n", name, money)
  93.     return false
  94. }

chain_test.go

  1. package chain
  3. func ExampleChain() {
  4.     c1 := NewProjectManagerChain()
  5.     c2 := NewDepManagerChain()
  6.     c3 := NewGeneralManagerChain()
  8.     c1.SetSuccessor(c2)
  9.     c2.SetSuccessor(c3)
  11.     var c Manager = c1
  13.     c.HandleFeeRequest("bob", 400)
  14.     c.HandleFeeRequest("tom", 1400)
  15.     c.HandleFeeRequest("ada", 10000)
  16.     c.HandleFeeRequest("floar", 400)
  17.     // Output:
  18.     // Project manager permit bob 400 fee request
  19.     // Dep manager permit tom 1400 fee request
  20.     // General manager permit ada 10000 fee request
  21.     // Project manager don't permit floar 400 fee request
  23. }