1. 概述

仲裁者（Mediator）可以封装和协调多个对象之间的耦合交互行为，以减弱这些对象之间的耦合关联。

1.1 作用

将多个对象相互耦合的设计转变为所有对象通过中介协作，从而降低其耦合性

多个对象相互耦合：

所有对象通过中介（E）相互协作

1.2 角色

抽象仲裁者（Mediator）角色：封装和实现其子类的协作行为。
具体仲裁者（ConcreteMediator）角色：实现仲裁者行为。
抽象协作者类（Colleague）角色：持有指向仲裁者Mediator对象的引用
具体协作者（ConcreteColleague）：

1.3 类图

2. 代码示例

2.1 设计

• 定义抽象仲裁者Mediator
• 定义具体仲裁者ConcreteMediator
  • 它依赖了需要的具体协作者ConcreteColleagueA、ConcreteColleagueB、ConcreteColleagueC
  • 它的Process()方法选择了如何执行何种实际协作者
• 定义了抽象协作者Colleague
• 定义了各个实际协作者ConcreteColleagueA、ConcreteColleagueB、ConcreteColleagueC
  • 它们实现了抽象协作者Colleague
  • 它们都依赖了抽象仲裁者Mediator
  • 它们的Action()方法，通过所依赖的仲裁者，执行对应的实际协作者的Option()方法
  • 它们的Option()方法，是实际协作中的操作
• 调用
  • 实例化一个具体仲裁者
  • 实例化三个具体协作者
  • 每个具体协作者关联仲裁者实例
  • 分别执行三个仲裁者的Action()方法完成每一次协作

2.2 代码

• 代码

package main

import "fmt"

// 抽象中介
type Mediator interface {
	Process(colleague Colleague)
}

// 实际中介，它持有所有具体协作者
type ConcreteMediator struct {
	concreteColleagueA *ConcreteColleagueA
	concreteColleagueB *ConcreteColleagueB
	concreteColleagueC *ConcreteColleagueC
}

// 该方法实现了各协作者之间通过实际中介的相互协作（该例中实际中介同时维护了实际协作者的协作关系）
func (cm *ConcreteMediator) Process(colleague Colleague) {
	switch {
	case colleague == cm.concreteColleagueA:
		cm.concreteColleagueA.Option()
		cm.concreteColleagueC.Option()
	case colleague == cm.concreteColleagueB:
		cm.concreteColleagueB.Option()
		cm.concreteColleagueC.Option()
	case colleague == cm.concreteColleagueC:
		cm.concreteColleagueC.Option()
	}
}

// 抽象协作者
type Colleague interface {
	Action()
}

// 定义实际协作者A，它关联了中介
type ConcreteColleagueA struct {
	mediator Mediator
}

// 该方法调用中介，已达到调用其他协作者的目的（调用顺序由中介维护）
func (a *ConcreteColleagueA) Action() {
	a.mediator.Process(a)
}

// 该方法是协作者A自身的操作
func (e *ConcreteColleagueA) Option() {
	fmt.Println("ConcreteColleagueA")
}

// 实际协作者B(说明同协作者A)
type ConcreteColleagueB struct {
	mediator Mediator
}

func (e *ConcreteColleagueB) Action() {
	e.mediator.Process(e)
}

func (e *ConcreteColleagueB) Option() {
	fmt.Println("ConcreteColleagueB")
}

// 实际协作者C(说明同协作者A)
type ConcreteColleagueC struct {
	mediator Mediator
}

func (t *ConcreteColleagueC) Action() {
	t.mediator.Process(t)
}

func (t *ConcreteColleagueC) Option() {
	fmt.Println("ConcreteColleagueC")
}

func main() {
	//实例化一个具体中介
	concreteMediator := &ConcreteMediator{}
	//实例化三个实际协作者
	concreteColleagueA := &ConcreteColleagueA{
		mediator: concreteMediator,
	}
	concreteColleagueB := &ConcreteColleagueB{
		mediator: concreteMediator,
	}
	concreteColleagueC := &ConcreteColleagueC{
		mediator: concreteMediator,
	}
	//具体中介应持有所有协作者
	concreteMediator.concreteColleagueA = concreteColleagueA
	concreteMediator.concreteColleagueB = concreteColleagueB
	concreteMediator.concreteColleagueC = concreteColleagueC

	//协作者A的Action()方法向它的实际中介请求，并由中介按它维护的顺序依次调用协作者
	concreteColleagueA.Action()
	//协作者A的Action()方法向它的实际中介请求，并由中介按它维护的顺序依次调用协作者
	concreteColleagueB.Action()
	//协作者A的Action()方法向它的实际中介请求，并由中介按它维护的顺序依次调用协作者
	concreteColleagueC.Action()
}

• 输出

2.3 类图