行為型：八. 中介者模式

中介模式是什麼

中介者模式是一種行為設計模式，用一個中介對象來封裝一系列的對象交互。中介者使各對象不需要顯式地相互引用，從而使其耦合鬆散，而且可以相互獨立地改變它們之間地交互。

為什麼用中介模式

中介者模式建議你停止組件之間的直接交流並使其相互獨立。這些組件必須調用特殊的中介者對象，通過中介者對象重定向調用行為， 以間接的方式進行合作。 最終， 組件僅依賴於一個中介者類， 無需與多個其他組件相耦合。

中介模式怎麼實現

這裡是用火車進站來舉例只有在站臺空閑的時候火車才可以進站，而車站的調度就是中介，每列火車都是和車站調度(中介)來溝通的。

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. 一段時間後， 中介者可能會演化成為上帝對象。