go-浅学设计模式随记

责任链模式

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

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

场景:常见逻辑层处理逻辑:获取参数、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())
 }
}
作者:小陈努力努力再努力原文地址:https://www.cnblogs.com/chenjianhui254/p/17015061.html

%s 个评论

要回复文章请先登录注册