行为型：八. 中介者模式

中介模式是什么

中介者模式是一种行为设计模式，用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以相互独立地改变它们之间地交互。

为什么用中介模式

中介者模式建议你停止组件之间的直接交流并使其相互独立。这些组件必须调用特殊的中介者对象，通过中介者对象重定向调用行为， 以间接的方式进行合作。 最终， 组件仅依赖于一个中介者类， 无需与多个其他组件相耦合。

中介模式怎么实现

这里是用火车进站来举例只有在站台空闲的时候火车才可以进站，而车站的调度就是中介，每列火车都是和车站调度(中介)来沟通的。

mediator.go 中介

package mediator

type mediator interface {
	canArrive(train) bool
	notifyAboutDeparture()
}

type stationManager struct {
	isPlatformFree bool  // 站台是否空闲
	trainQueue     []train
}

func newStationManger() *stationManager {
	return &stationManager{
		isPlatformFree: true,
	}
}

func (s *stationManager) canArrive(t train) bool {
	if s.isPlatformFree {
		s.isPlatformFree = false
		return true
	}
	s.trainQueue = append(s.trainQueue, t)
	return false
}

func (s *stationManager) notifyAboutDeparture() {
	if !s.isPlatformFree {
		s.isPlatformFree = true
	}
	if len(s.trainQueue) > 0 {
		firstTrainInQueue := s.trainQueue[0]
		s.trainQueue = s.trainQueue[1:]
		firstTrainInQueue.permitArrival()
	}
}

train.go 火车组件

type train interface {
	arrive() // 到达
	depart()
	permitArrival()
}

passenger_train.go 客运火车

package mediator

import "fmt"

// 客运火车

type passengerTrain struct {
	mediator mediator
}

func (p *passengerTrain) arrive() {
	if !p.mediator.canArrive(p) {
		fmt.Println("客运火车到达，等待入站")
		return
	}
	fmt.Println("客运火车入站")
}

func (p *passengerTrain) depart() {
	fmt.Println("客运火车离开")
	p.mediator.notifyAboutDeparture()
}

func (p *passengerTrain) permitArrival() {
	fmt.Println("客运火车允许入站")
	p.arrive()
}

freight_train.go 货运火车

package mediator

import "fmt"

// 货运火车

type freightTrain struct {
	mediator mediator
}

func (g *freightTrain) arrive() {
	if !g.mediator.canArrive(g) {
		fmt.Println("货运火车到达，等待入站")
		return
	}
	fmt.Println("货运火车入站")
}

func (g *freightTrain) depart() {
	fmt.Println("货运火车离开")
	g.mediator.notifyAboutDeparture()
}

func (g *freightTrain) permitArrival() {
	fmt.Println("货运火车允许入站")
	g.arrive()
}

调用示例

package mediator

func Example() {
	stationManager := newStationManger()

	passengerTrain := &passengerTrain{
		mediator: stationManager,
	}
	freightTrain := &freightTrain{
		mediator: stationManager,
	}

	passengerTrain.arrive()
	freightTrain.arrive()
	passengerTrain.depart()
}

// 客运火车入站
// 货运火车到达，等待入站
// 客运火车离开
// 货运火车允许入站
// 货运火车入站

优点

1. 单一职责原则。 你可以将多个组件间的交流抽取到同一位置， 使其更易于理解和维护。
2. 开闭原则。 你无需修改实际组件就能增加新的中介者。
3. 你可以减轻应用中多个组件间的耦合情况。

缺点

1. 一段时间后， 中介者可能会演化成为上帝对象。