Golang - Design Pattern #13: 仲介者模式 ( Mediator)

🔗 將物件解耦合 🔗

你還記得在學校時代，當兩位朋友吵架時，有時會有第三者出來做調解嗎？在程式設計中，我們有一種模式就像那位調解者，幫助兩個物件之間保持距離，這就是仲介者模式( Mediator Pattern )！

仲介者模式是啥？

仲介者模式使用一個獨立的物件來封裝一系列的物件之間的互動。目的是使這些物件不直接互動，減少它們之間的依賴。這樣當其中一個物件改變時，不會影響到其他物件。

實際的例子

📱 聊天應用

想像你正在使用一個群組聊天應用，每當有人發送消息，其它人都可以看到。在這裡，聊天室就是仲介者，用戶只需告訴聊天室他們要傳遞的消息，然後聊天室會通知其他用戶。

package main

import "fmt"

// User represents each individual in the chat
type User struct {
	Name         string
	ChatMediator Mediator
}

// SendMessage sends the user's message to the chat room
func (u *User) SendMessage(message string) {
	u.ChatMediator.SendMessage(message, u)
}

// ReceiveMessage is called when a message is received from the chat room
func (u *User) ReceiveMessage(message string) {
	fmt.Printf("%s received: %s\n", u.Name, message)
}

// Mediator is an interface representing the middle-man in communication
type Mediator interface {
	SendMessage(string, *User)
}

// ChatRoom acts as the mediator for user messages
type ChatRoom struct {
	Users []*User
}

// SendMessage broadcasts the message from the sender to all other users in the chat room
func (c *ChatRoom) SendMessage(message string, user *User) {
	for _, u := range c.Users {
		if u != user {
			u.ReceiveMessage(message)
		}
	}
}

func main() {
	alice := &User{Name: "Alice"}
	bob := &User{Name: "Bob"}
	chatRoom := &ChatRoom{Users: []*User{alice, bob}}
	alice.ChatMediator = chatRoom
	bob.ChatMediator = chatRoom
	alice.SendMessage("Hi Bob!")
	bob.SendMessage("Hello Alice!")
}
​

🚦 交通指揮中心

想像一下城市中的交通燈。如果每個交通燈都自行運作，可能會引起混亂。我們需要一個交通指揮中心來協調它們。

package main

import (
	"fmt"
)

type Mediator interface {
	Notify(sender TrafficLight, event string)
}

type TrafficCommandCenter struct {
	lights []*TrafficLight
}

func (tcc *TrafficCommandCenter) Notify(sender TrafficLight, event string) {
	if event == "GREEN" {
		for _, light := range tcc.lights {
			if light != &sender {
				light.TurnRed()
			}
		}
	}
}

type TrafficLight struct {
	color    string
	mediator Mediator
}

func (tl *TrafficLight) TurnGreen() {
	tl.color = "GREEN"
	tl.mediator.Notify(*tl, "GREEN")
	fmt.Println("Traffic light is now GREEN!")
}

func (tl *TrafficLight) TurnRed() {
	tl.color = "RED"
	fmt.Println("Traffic light is now RED!")
}

func main() {
	tcc := &TrafficCommandCenter{}
	light1 := &TrafficLight{color: "RED", mediator: tcc}
	light2 := &TrafficLight{color: "RED", mediator: tcc}
	tcc.lights = append(tcc.lights, light1, light2)

	light1.TurnGreen()  // This should turn light1 to GREEN and light2 to RED
	light2.TurnGreen()  // This should turn light2 to GREEN and light1 to RED
}

為什麼要用仲介者模式？

1. 減少物件間的耦合：使用仲介者可以減少物件間的直接依賴，使得系統更加模組化。
2. 集中控制：仲介者提供了一個集中的地方來管理和調整物件間的互動。

小結

仲介者模式可以幫助我們管理和調整物件間的互動。使用它，我們可以確保物件間的互動是有序的，並且可以輕鬆地進行調整。在設計大型系統時，這種模式可以為我們提供很大的便利 ~~~👏