设计模式--中介者(Mediator)模式

模式定义

用一个中介对象来封装（封装变化）一系列的对象交互，中介者使各对象不需要显示的相互引用，从而使其耦合松散（管理变化），而且可以独立地改变它们之间的交互

类图

应用场景

当多个对象互相关联交互并存在复杂的引用关系时，且对新需求需要进行大量更改时使用中介者模式解耦合

优点

可以避免相互交互的对象之间的紧耦合引用关系，从而更好地抵御变化

要点总结

要点总结

• 将多个对象间复杂的关联关系解耦，Mediator模式将多个对象间的控制逻辑进行集中管理，变“多个对象互相关联”为“多个对象和一个中介者关联”，简化了系统的维护，抵御了可能的变化
• 随着控制逻辑的复杂化，Mediator具体对象的实现可能相当复杂，这时候可以对Mediator对象进行分解处理
• Facade模式是解耦系统间（单向）的对象关联关系，Mediator模式是解耦系统内各个对象之间（双向）的关联关系

Go语言代码实现

中介者模式（Mediator Pattern）是一种行为型设计模式，它通过引入一个中介者对象来协调多个对象之间的交互。中介者模式通过将对象之间的通信集中在中介者对象中，而不是直接相互通信，从而降低了对象之间的耦合度。

中介者模式的核心思想是将对象之间的交互行为集中到中介者对象中，而不是让对象直接相互引用和通信。通过这种方式，各个对象只需与中介者进行交互，而不需要了解其他对象的具体细节，从而减少了对象之间的依赖关系。

以下是一个简单的例子来说明中介者模式的应用：

package main

import "fmt"

// Mediator 中介者接口
type Mediator interface {
	SendMessage(message string, colleague Colleague)
}

// Colleague 同事接口
type Colleague interface {
	SendMessage(message string)
	ReceiveMessage(message string)
}

// ConcreteMediator 具体中介者
type ConcreteMediator struct {
	colleague1 Colleague
	colleague2 Colleague
}

func (m *ConcreteMediator) SetColleague1(colleague Colleague) {
	m.colleague1 = colleague
}

func (m *ConcreteMediator) SetColleague2(colleague Colleague) {
	m.colleague2 = colleague
}

func (m *ConcreteMediator) SendMessage(message string, colleague Colleague) {
	if colleague == m.colleague1 {
		m.colleague2.ReceiveMessage(message)
	} else {
		m.colleague1.ReceiveMessage(message)
	}
}

// ConcreteColleague1 具体同事1
type ConcreteColleague1 struct {
	mediator Mediator
}

func (c *ConcreteColleague1) SetMediator(mediator Mediator) {
	c.mediator = mediator
}

func (c *ConcreteColleague1) SendMessage(message string) {
	c.mediator.SendMessage(message, c)
}

func (c *ConcreteColleague1) ReceiveMessage(message string) {
	fmt.Println("ConcreteColleague1 received:", message)
}

// ConcreteColleague2 具体同事2
type ConcreteColleague2 struct {
	mediator Mediator
}

func (c *ConcreteColleague2) SetMediator(mediator Mediator) {
	c.mediator = mediator
}

func (c *ConcreteColleague2) SendMessage(message string) {
	c.mediator.SendMessage(message, c)
}

func (c *ConcreteColleague2) ReceiveMessage(message string) {
	fmt.Println("ConcreteColleague2 received:", message)
}

func main() {
	mediator := &ConcreteMediator{}

	colleague1 := &ConcreteColleague1{}
	colleague1.SetMediator(mediator)
	mediator.SetColleague1(colleague1)

	colleague2 := &ConcreteColleague2{}
	colleague2.SetMediator(mediator)
	mediator.SetColleague2(colleague2)

	colleague1.SendMessage("Hello, colleague2!")
	colleague2.SendMessage("Hi, colleague1!")
}

在上述示例中，我们定义了一个中介者接口Mediator和同事接口Colleague，其中中介者接口包含了发送消息的方法，同事接口包含了发送消息和接收消息的方法。

然后，我们创建了一个具体的中介者对象ConcreteMediator，它持有两个具体的同事对象ConcreteColleague1和ConcreteColleague2。中介者对象负责协调两个同事对象之间的交互。

具体同事对象实现了同事接口，并通过持有中介者对象来发送和接收消息。当同事对象发送消息时，它会调用中介者对象的发送消息方法，中介者根据发送消息的同事对象决定将消息发送给另一个同事对象。

在main函数中，我们创建了中介者对象和两个同事对象，并设置它们之间的关系。然后，我们通过同事对象发送消息，中介者对象会将消息传递给另一个同事对象，并进行相应的处理。

通过中介者模式，我们可以实现对象之间的松耦合，将复杂的交互逻辑集中到中介者对象中，使各个对象之间的通信更加简单和可控。