mediator.go
最后更新于：2022-04-02 04:50:03
~~~
/*
Mediator 中介者模式：
用一个中介对象来封装一系列的对象交互。
中介这使各对象不需要显式地相互引用，从而使其耦合松散，
而且可以独立地改变它们之间的交互。
个人想法：每个对象都有一个中介者对象，发生变化时，通知中介者，由中介者判断通知其他的对象。
作者： HCLAC
*/
package Mediator
import (
"fmt"
)
// 中介者接口
type IMediator interface {
Send(string, IColleague)
}
// 实现中介者接口的基本类型
type Mediator struct {
}
// 具体的中介者
type ConcreteMediator struct {
Mediator
colleagues []IColleague
}
func (m *ConcreteMediator) AddColleague(c IColleague) {
if m == nil {
return
}
m.colleagues = append(m.colleagues, c)
}
func (m *ConcreteMediator) Send(message string, c IColleague) {
if m == nil {
return
}
for _, val := range m.colleagues {
if c == val {
continue
}
val.Notify(message)
}
}
func NewConcreteMediator() *ConcreteMediator {
return &ConcreteMediator{}
}
// 合作者接口
type IColleague interface {
Send(string)
Notify(string)
}
// 实现合作者接口的基本类型
type Colleague struct {
mediator IMediator
}
// 具体合作者对象A
type ConcreteColleageA struct {
Colleague
}
func (c *ConcreteColleageA) Notify(message string) {
if c == nil {
return
}
fmt.Println("ConcreteColleageA get message:", message)
}
func (c *ConcreteColleageA) Send(message string) {
if c == nil {
return
}
c.mediator.Send(message, c)
}
func NewConcreteColleageA(mediator IMediator) *ConcreteColleageA {
return &ConcreteColleageA{Colleague{mediator}}
}
// 具体合作者对象B
type ConcreteColleageB struct {
Colleague
}
func (c *ConcreteColleageB) Notify(message string) {
if c == nil {
return
}
fmt.Println("ConcreteColleageB get message:", message)
}
func (c *ConcreteColleageB) Send(message string) {
if c == nil {
return
}
c.mediator.Send(message, c)
}
func NewConcreteColleageB(mediator IMediator) *ConcreteColleageB {
return &ConcreteColleageB{Colleague{mediator}}
}
~~~
';