type ObServer struct { Id int }
func (s *ObServer) Update(event *Event) { fmt.Printf("observer %d msg: %s", s.Id, event.Data) }
type Subject struct { ObServers map[IObServer]struct{} }
func NewSubject() *Subject { return &Subject{ObServers: make(map[IObServer]struct{})} }
func (s *Subject) Register(server IObServer) { s.ObServers[server] = struct{}{} }
func (s *Subject) Remove(server IObServer) { delete(s.ObServers, server) }
func (s *Subject) Notify(event *Event) { for ob, _ := range s.ObServers { ob.Update(event) } }
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)
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
