场景
如果在一个程序中对象之间的联系呈现为网状结构，如图1所示，对象之间存在大量的多对多联系，将导致程序非常复杂，这些对象既会影响别的对象，也会被别的对象所影响，这些对象称为同事对象。在网状结构中，几乎每个对象都需要与其他对象发生相互作用，而这种相互作用表现为一个对象与另外一个对象的直接耦合，这将导致一个过度耦合的程序
问题改进
中介者模式可以使对象之间的关系数量急剧减少，通过引入中介者对象，可以将程序的网状结构变成以中介者为中心的星形结构，如图2所示，在这个星形结构中，同事对象不再直接与另一个对象联系，它通过中介者对象与另一个对象发生相互作用。中介者对象的存在保证了对象结构上的稳定，也就是说，程序的结构不会因为新对象的引入带来大量的修改工作
如果在一个程序中对象之间存在多对多的相互关系，我们可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。通过引入中介者来简化对象之间的复杂交互，中介者模式是“迪米特法则”的一个典型应用
表述 (行为型模式)
用一个中介对象来封装一系列对象的交互方式，中介者使各个对象不需要显示地相互引用，从而使其耦合松散，而且可以独立的改变它们之间的交互
中介者模式类图
Mediator（抽象中介者）：定义一个接口，该接口用于中介者与各同事对象之间进行通信
ConcreteMediator（具体中介者对象）：抽象中介者的子类，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用
Colleague（抽象同事类）：定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信
ConcreteColleague1和ConcreteColleague2（具体同事类）：抽象同事类的子类；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信
优点
- 简化了对象之间的交互，用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构
- 各同事对象之间解耦，中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”
- 减少子类生成：中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使各个同事类可被重用，无须对同事类进行扩展
缺点
在具体中介者类中包含了大量同事之间的交互细节，可能会导致具体中介者类非常复杂，使得程序难以维护。
使用场景
- 对象间的交互虽定义明确然而非常复杂，导致一组对象彼此相互依赖而且难以理解
- 因为对象引用了许多其他对象并与其通信，导致对象难以复用
- 想要定制一个分布在多个类中的逻辑或者行为，又不想生成太多子类
示例
需求：假设现在有A、B、C建立了一个微信讨论组，他们有什么问题就在这里讨论，A在犹豫今天中午吃什么，A同学只要在讨论组里问一声就可以了，不必要直接去和B、C同学打交道，省去了很多麻烦事。怎么实现呢？
中介者
class Mediator {
func chat(per:People,message:String) {
}
}
class ConcreteMediator : Mediator {
//持有各个同事对象
var perA:PeopleA?
var perB:PeopleB?
var perC:PeopleC?
func setPerA(a:PeopleA) {
self.perA = a
}
func setPerB(b:PeopleB) {
self.perB = b
}
func setPerC(c:PeopleC) {
self.perC = c
}
override func chat(per: People, message: String) {
if per === perA {
perA!.send(message: message)
perB?.receive(message: message)
perC?.receive(message: message)
}else if per === perB {
perB!.send(message: message)
perA!.receive(message: message)
perC!.receive(message: message)
}else{
perC?.send(message: message)
perA?.receive(message: message)
perB?.receive(message: message)
}
}
}
同事类
class People{
//持有一个中介者对象
var mediator : Mediator
var name : String
init(mediator:Mediator,name : String) {
self.mediator = mediator
self.name = name
}
func getMediator() -> Mediator {
return mediator
}
func receive(message:String) {
}
func send(message:String) {
}
}
class PeopleA: People {
override init(mediator: Mediator, name: String) {
super.init(mediator: mediator, name: name)
}
override func receive(message: String) {
print("A收到消息：\(message)")
}
override func send(message: String) {
print("A发送消息：\(message)")
}
}
class PeopleB: People {
override init(mediator: Mediator, name: String) {
super.init(mediator: mediator, name: name)
}
override func receive(message: String) {
print("B收到消息：\(message)")
}
override func send(message: String) {
print("B发送消息：\(message)")
}
}
class PeopleC: People {
override init(mediator: Mediator, name: String) {
super.init(mediator: mediator, name: name)
}
override func receive(message: String) {
print("C收到消息：\(message)")
}
override func send(message: String) {
print("C发送消息：\(message)")
}
}
客户端
let mediator = ConcreteMediator.init()
let pA = PeopleA.init(mediator: mediator, name: "A")
let pB = PeopleB.init(mediator: mediator, name: "B")
let pC = PeopleC.init(mediator: mediator, name: "C")
mediator.setPerA(a: pA)
mediator.setPerB(b: pB)
mediator.setPerC(c: pC)
mediator.chat(per: pA, message: "中午吃啥饭？")
mediator.chat(per: pB, message: "我想吃刀削面")
mediator.chat(per: pC, message: "我也想吃刀削面")
mediator.chat(per: pA, message: "行，那中午一起去吃刀削面吧")
log:
//A发送消息：中午吃啥饭？
//B收到消息：中午吃啥饭？
//C收到消息：中午吃啥饭？
//B发送消息：我想吃刀削面
//A收到消息：我想吃刀削面
//C收到消息：我想吃刀削面
//C发送消息：我也想吃刀削面
//A收到消息：我也想吃刀削面
//B收到消息：我也想吃刀削面
//A发送消息：行，那中午一起去吃刀削面吧
//B收到消息：行，那中午一起去吃刀削面吧
//C收到消息：行，那中午一起去吃刀削面吧
