访问者模式

11.1 模式动机

访问者模式可以给一系列对象透明的添加功能，并且把相关代码封装到一个类中。

对象只要预留访问者接口Accept则后期为对象添加功能的时候就不需要改动对象。

10.2 Go语言实现

visitor.go

  1. package visitor
  3. import "fmt"
  5. type Customer interface {
  6.     Accept(Visitor)
  7. }
  9. type Visitor interface {
  10.     Visit(Customer)
  11. }
  13. type EnterpriseCustomer struct {
  14.     name string
  15. }
  17. type CustomerCol struct {
  18.     customers []Customer
  19. }
  21. func (c *CustomerCol) Add(customer Customer) {
  22.     c.customers = append(c.customers, customer)
  23. }
  25. func (c *CustomerCol) Accept(visitor Visitor) {
  26.     for _, customer := range c.customers {
  27.         customer.Accept(visitor)
  28.     }
  29. }
  31. func NewEnterpriseCustomer(name string) *EnterpriseCustomer {
  32.     return &EnterpriseCustomer{
  33.         name: name,
  34.     }
  35. }
  37. func (c *EnterpriseCustomer) Accept(visitor Visitor) {
  38.     visitor.Visit(c)
  39. }
  41. type IndividualCustomer struct {
  42.     name string
  43. }
  45. func NewIndividualCustomer(name string) *IndividualCustomer {
  46.     return &IndividualCustomer{
  47.         name: name,
  48.     }
  49. }
  51. func (c *IndividualCustomer) Accept(visitor Visitor) {
  52.     visitor.Visit(c)
  53. }
  55. type ServiceRequestVisitor struct{}
  57. func (*ServiceRequestVisitor) Visit(customer Customer) {
  58.     switch c := customer.(type) {
  59.     case *EnterpriseCustomer:
  60.         fmt.Printf("serving enterprise customer %s\n", c.name)
  61.     case *IndividualCustomer:
  62.         fmt.Printf("serving individual customer %s\n", c.name)
  63.     }
  64. }
  66. // only for enterprise
  67. type AnalysisVisitor struct{}
  69. func (*AnalysisVisitor) Visit(customer Customer) {
  70.     switch c := customer.(type) {
  71.     case *EnterpriseCustomer:
  72.         fmt.Printf("analysis enterprise customer %s\n", c.name)
  73.     }
  74. }

visitor_test.go

  1. package visitor
  3. func ExampleRequestVisitor() {
  4.     c := &CustomerCol{}
  5.     c.Add(NewEnterpriseCustomer("A company"))
  6.     c.Add(NewEnterpriseCustomer("B company"))
  7.     c.Add(NewIndividualCustomer("bob"))
  8.     c.Accept(&ServiceRequestVisitor{})
  9.     // Output:
  10.     // serving enterprise customer A company
  11.     // serving enterprise customer B company
  12.     // serving individual customer bob
  13. }
  15. func ExampleAnalysis() {
  16.     c := &CustomerCol{}
  17.     c.Add(NewEnterpriseCustomer("A company"))
  18.     c.Add(NewIndividualCustomer("bob"))
  19.     c.Add(NewEnterpriseCustomer("B company"))
  20.     c.Accept(&AnalysisVisitor{})
  21.     // Output:
  22.     // analysis enterprise customer A company
  23.     // analysis enterprise customer B company
  24. }