责任链模式

组成：由多个处理器及处理器处理标志串联组成

作用：常用于处理流水线事务，利用多个处理器对同一个对象进行处理，可以利用各处理器开关

场景：常见逻辑层处理逻辑：获取参数、fetch数据、逻辑处理数据、返回参数一系列数据处理

优点：将复杂的流水线处理逻辑简化为一个个单元，操作较为便捷，可以随意在处理器之间串联穿插新处理器

package burden_chain

import "fmt"

/*
   责任链模式
   组成：由多个处理器及处理器处理标志串联组成
   作用：常用于处理流水线事务，利用多个处理器对同一个对象进行处理，可以利用各处理器开关
   场景：常见的获取参数、fetch数据、逻辑处理数据、返回参数一系列数据连续化处理
   优点：将复杂的流水线处理逻辑简化为一个个单元，操作较为便捷，可以随意在处理器之间串联穿插新处理器
*/

// CalProcessor 处理器抽象接口
type CalProcessor interface {
   SetNextProcessor(processor CalProcessor)
   ProcessFor(calIdentity *CalIdentity)
}

// CalIdentity 处理对象实体
type CalIdentity struct {
   A          int
   B          int
   sum        int
   hasGetA    bool // GetAProcessor开关：是否获取到A
   hasGetB    bool // GetBProcessor开关：是否获取到B
   hasAdd     bool // SumProcessor开关：A与B是否相加
   isComplete bool // CompleteProcessor开关：完成计算
}

// baseCalProcessor 基类实现CalProcessor
type baseCalProcessor struct {
   nextCalProcessor CalProcessor
}

// SetNextProcessor 用于串联处理器
func (b *baseCalProcessor) SetNextProcessor(processor CalProcessor) {
   b.nextCalProcessor = processor
}

// ProcessFor 用于承接处理器的执行逻辑
func (b *baseCalProcessor) ProcessFor(calIdentity *CalIdentity) {
   if b.nextCalProcessor != nil {
      b.nextCalProcessor.ProcessFor(calIdentity)
   }
}

// GetAProcessor 获取数字A处理器
type GetAProcessor struct {
   baseCalProcessor
}

func (g *GetAProcessor) ProcessFor(calIdentity *CalIdentity) {
   if !calIdentity.hasGetA {
      fmt.Println("getting number A.")
   }
   fmt.Println("A")
   calIdentity.hasGetA = true
   g.nextCalProcessor.ProcessFor(calIdentity)
}

// GetBProcessor 获取数字B处理器
type GetBProcessor struct {
   baseCalProcessor
}

func (g *GetBProcessor) ProcessFor(calIdentity *CalIdentity) {
   if !calIdentity.hasGetA {
      fmt.Println("didn't get number A.")
      return
   }
   fmt.Println("B")
   calIdentity.hasGetB = true
   g.nextCalProcessor.ProcessFor(calIdentity)
}

// SumProcessor 加法处理器
type SumProcessor struct {
   baseCalProcessor
}

func (g *SumProcessor) ProcessFor(calIdentity *CalIdentity) {
   if !calIdentity.hasGetA || !calIdentity.hasGetB {
      fmt.Println("didn't get number A or B")
      return
   }
   fmt.Println("A plus B")
   calIdentity.hasAdd = true
   g.nextCalProcessor.ProcessFor(calIdentity)
}

// CompleteProcessor 完成处理器
type CompleteProcessor struct {
   baseCalProcessor
}

func (c *CompleteProcessor) ProcessFor(calIdentity *CalIdentity) {
   if !calIdentity.hasGetA || !calIdentity.hasGetB || !calIdentity.hasAdd {
      fmt.Println("cal not done.")
      return
   }
   fmt.Println("done")
   calIdentity.isComplete = true
   return
}

测试类

package burden_chain

import "testing"

func TestChainResponsibility(t *testing.T) {
   calProcessor := BuildCalProcessorChain()
   calIdentity := &CalIdentity{
      A:          0,
      B:          0,
      sum:        0,
      hasGetA:    false,
      hasGetB:    true,
      hasAdd:     false,
      isComplete: false,
   }
   calProcessor.ProcessFor(calIdentity)
}

// BuildCalProcessorChain: GetAProcessor -> GetBProcessor -> SumProcessor -> CompleteProcessor
func BuildCalProcessorChain() CalProcessor {
   completeCheckNode := &CompleteProcessor{}

   sumCheckNode := &SumProcessor{}
   sumCheckNode.SetNextProcessor(completeCheckNode)

   getBCheckNode := &GetBProcessor{}
   getBCheckNode.SetNextProcessor(sumCheckNode)

   getACheckNode := &GetAProcessor{}
   getACheckNode.SetNextProcessor(getBCheckNode)

   return getACheckNode
}

命令模式

组成：接受者、指令触发器
作用：将请求方法参数化，将指令抽象，便于在指令与指令之间建立独立的逻辑操作关系

场景：适用于任务定制需求，比如818活动等等，在特点的时间节点，使用特定的功能需求。

优点：将指令单元化，通过统一的的Execute接口方法进行调用，屏蔽各个请求的差异，便于多命令组装、回滚，屏蔽各个请求的差异

接受者

package order_pattern

type ReceiverA struct {
   height int
   width  int
}

func (s *ReceiverA) SetHeight(height int) {
   s.height = height
}

func (s *ReceiverA) SetWidth(width int) {
   s.width = width
}

func (s *ReceiverA) Shutdown() string {
   return "shut down this formulation."
}

指令触发器

package order_pattern

import "fmt"

/*
   命令模式
   组成：接受者、指令触发器
   作用：将请求方法参数化，将指令抽象，便于在指令与指令之间建立独立的逻辑操作关系
   优点：将指令单元化，通过统一的的Execute接口方法进行调用，屏蔽各个请求的差异，便于多命令组装、回滚，屏蔽各个请求的差异
*/

type CalCommand interface {
   Execute() string
}

// CalCircleCommand 计算周长
type CalCircleCommand struct {
   receiver *ReceiverA
}

// 指令将接受者内嵌
func NewCalCircleCommand(receiver *ReceiverA) *CalCircleCommand {
   return &CalCircleCommand{receiver: receiver}
}

// 利用各个指令内置方法，将不同指令的执行过程屏蔽，便于扩展
func (c *CalCircleCommand) Execute() string {
   c.receiver.SetWidth(2)
   c.receiver.SetHeight(3)
   return fmt.Sprintf("the circle of receiver is %.2f", float64(2*(c.receiver.width+c.receiver.height)))
}

// CalAreaCommand 计算面积
type CalAreaCommand struct {
   receiver *ReceiverA
}

func NewCalAreaCommand(receiver *ReceiverA) *CalAreaCommand {
   return &CalAreaCommand{receiver: receiver}
}

func (c *CalAreaCommand) Execute() string {
   c.receiver.SetWidth(2)
   c.receiver.SetHeight(3)
   return fmt.Sprintf("the area of receiver is %.2f", float64(c.receiver.height*c.receiver.width))
}

type CommandInvoker struct {
   calCommand CalCommand
}

func (c *CommandInvoker) SetCommand(calCommand CalCommand) {
   c.calCommand = calCommand
}

func (c *CommandInvoker) ExecuteCommand() string {
   return c.calCommand.Execute()
}

测试类

package order_pattern

import (
   "fmt"
   "testing"
)

func TestOrderPattern(t *testing.T) {
   receiver := new(ReceiverA)
   commandInvoker := new(CommandInvoker)

   circleCommand := NewCalCircleCommand(receiver)
   commandInvoker.SetCommand(circleCommand)
   fmt.Println(commandInvoker.ExecuteCommand())

   areaCommand := NewCalAreaCommand(receiver)
   commandInvoker.SetCommand(areaCommand)
   fmt.Println(commandInvoker.ExecuteCommand())
}

迭代器模式

组成：创建迭代器的工厂方法接口Iterable、迭代器本身本身的接口memberIterator
作用：用于在不暴露集合底层表现形式的情况下遍历集合中的所有元素，即在迭代器的帮助下，客户端可以用一个迭代器接口以相似的方法遍历不同集合中的元素
场景：适用于为迭代遍历来自两个及以上不同类型的集合中的元素，无视集合的底层类型，只通过暴露出的Next和HasNext来访问元素

实体类

package iterator_pattern

import "fmt"

// Member 成员抽象接口
type Member interface {
   Info() string
}

// Teacher 教师实体
type Teacher struct {
   Name    string
   Subject string
}

// NewTeacher 创建教师实体
func NewTeacher(name, subject string) *Teacher {
   return &Teacher{
      Name:    name,
      Subject: subject,
   }
}

// Info 返回教师信息
func (t *Teacher) Info() string {
   return fmt.Sprintf("%s老师负责的科目-%s", t.Name, t.Subject)
}

// Student 学生实体
type Student struct {
   Name     string
   SumScore int
}

// NewStudent 创建学生实体
func NewStudent(name string, score int) *Student {
   return &Student{
      Name:     name,
      SumScore: score,
   }
}

// Info 返回学生信息
func (s *Student) Info() string {
   return fmt.Sprintf("%s同学考试分数:%d", s.Name, s.SumScore)
}

迭代器

package iterator_pattern

/*
   迭代器模式
   组成：创建迭代器的工厂方法接口Iterable、迭代器本身本身的接口memberIterator
   作用：用于在不暴露集合底层表现形式的情况下遍历集合中的所有元素，即在迭代器的帮助下，客户端可以用一个迭代器接口以相似的方法遍历不同集合中的元素
   场景：适用于为迭代遍历来自两个及以上不同类型的集合中的元素，无视集合的底层类型，只通过暴露出的Next和HasNext来访问元素
*/

// Iterator 迭代器抽象接口
type Iterator interface {
   Next() Member
   HasNext() bool
}

// memberIterator 迭代器实现类
type memberIterator struct {
   class *Class
   index int
}

// Next 获取迭代器中的下一个元素
func (m *memberIterator) Next() Member {
   if m.index == -1 { // 若游标是-1，则返回老师
      m.index++
      return m.class.Teacher
   }

   student := m.class.Students[m.index] // 游标大于等于0，则返回学生
   m.index++
   return student
}

// HasNext 判断是否存在下一个元素
func (m *memberIterator) HasNext() bool { // 判断是否还有剩余需要迭代的元素
   return m.index < len(m.class.Students)
}

// Iterable 可迭代集合接口，实现此接口返回迭代器
type Iterable interface {
   CreateIterator() Iterator
}

// Class 包括班级id、老师和同学
type Class struct {
   Id       int
   Teacher  *Teacher
   Students []*Student
}

// NewClass 根据班级id、老师创建班级
func NewClass(id int, teacherName, subject string) *Class {
   return &Class{
      Id:      id,
      Teacher: NewTeacher(teacherName, subject),
   }
}

// GetClassID 获取班级id
func (c *Class) GetClassID() int {
   return c.Id
}

// AddStudent 增加学生
func (c *Class) AddStudent(students ...*Student) {
   c.Students = append(c.Students, students...)
}

// CreateIterator 创建班级迭代器
// 迭代器两要素：班级实体、迭代索引
func (c *Class) CreateIterator() Iterator {
   return &memberIterator{
      class: c,  // 待迭代容器
      index: -1, // 迭代索引初始化为-1，从老师开始迭代
   }
}

测试类

package iterator_pattern

import (
   "fmt"
   "testing"
)

func TestIterator(t *testing.T) {
   class := NewClass(1, "cjh", "CS")
   class.AddStudent(NewStudent("张三", 410),
      NewStudent("李四", 400))

   fmt.Printf("%d班级成员如下:\n", class.GetClassID())
   classIterator := class.CreateIterator()
   for classIterator.HasNext() {
      member := classIterator.Next()
      fmt.Println(member.Info())
   }
}