Go语言实现23种设计模式之行为型模式(中)_go sendmsg(interface{}(2)

最新推荐文章于 2024-07-25 22:24:14 发布

2401_84920041

最新推荐文章于 2024-07-25 22:24:14 发布

阅读量563

点赞数 30

分类专栏：面试学习路线阿里巴巴文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84920041/article/details/138989575

版权

面试同时被 3 个专栏收录

6 篇文章 0 订阅

订阅专栏

学习路线

6 篇文章 0 订阅

订阅专栏

阿里巴巴

6 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

func main() {
s := NewSubject()

o1 := ObServer{Id: 1}
o2 := ObServer{Id: 2}

s.Register(&o1)
s.Register(&o2)

s.Notify(&Event{Data: "123"})

}


#### 观察者模式优点


1. 你无需修改被观察者代码就能引入新的观察者
2. 你可以在运行时建立对象之间的联系


#### 观察者模式缺点


1. 观察者的通知顺序是随机的


### 备忘录模式


在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态


#### 适用场景


1. 回退场景、撤销重做
2. 备份与还原、快照与恢复


#### Go语言实现

type Memento struct {
State string
}

func (m *Memento) SetState(s string) {
m.State = s
}

func (m *Memento) GetState() string {
return m.State
}

func (m *Memento) CreateMemento() *Memento {
return &Memento{State: m.State}
}

type CareTaker struct {
memento *Memento
}

func (c *CareTaker) GetMemento() *Memento {
return c.memento
}

func (c *CareTaker) SetMemento(m *Memento) {
c.memento = m
}

func main() {
o := Memento{State: “running”}
fmt.Printf(“当前状态: %s”, o.State)

c := new(CareTaker)
c.SetMemento(o.CreateMemento())

o.SetState("finish")
fmt.Printf("修改后的状态: %s", o.State)

o.SetState(c.GetMemento().GetState())
fmt.Printf("还原后的状态: %s", o.State)

}


#### 备忘录模式优点


1. 能够很方便的回到某个历史状态
2. 实现了信息的封装，使用方不需要关心状态的保存细节


#### 备忘录模式缺点


1. 消耗资源


### 中介者模式


定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解


#### 适用场景


1. 系统中的对象之间存在复杂的引用关系，如相互依赖
2. 存在交互的公共行为，如果需要改变行为可增加中介者类


#### Go语言实现

type Item interface {
SendMsg(msg string)
GetMsg(msg string)
}

type User struct {
mediator *Mediator
}

func (u *User) SendMsg(msg string) {
u.mediator.ForwardMsg(u, msg)
}

func (u *User) GetMsg(msg string) {
fmt.Printf("user get msg: %s: ", msg)
}

type Server struct {
mediator *Mediator
}

func (s *Server) SendMsg(msg string) {
s.mediator.ForwardMsg(s, msg)
}

func (s *Server) GetMsg(msg string) {
fmt.Printf(“server get msg: %s”, msg)
}

type Mediator struct {
User
Server
}

func (m *Mediator) ForwardMsg(item Item, msg string) {
switch item.(type) {
case *User:
m.Server.GetMsg(msg)
break
case *Server:
m.User.GetMsg(msg)