在複雜系統中，物件之間往往需要頻繁地相互通訊。如果物件之間直接引用和依賴彼此，系統會變得複雜且難以維護。為了解決這種耦合問題，中介者模式（Mediator Pattern）應運而生。中介者模式透過引入一個獨立的中介者對象，來管理對象之間的交互，從而減少對象之間的直接依賴，使系統更加靈活。本文將深入介紹中介者模式的概念、與其他相似模式的差異、解決的問題、Golang中的實現以及注意事項。

什麼是中介者模式？

中介者模式（Mediator Pattern）是一種行為型設計模式，透過一個中介者物件來封裝物件之間的互動邏輯，使物件之間不再直接引用彼此，而是透過中介者進行溝通。這樣可以減少物件之間的耦合，使得系統更容易擴展和維護。

中介者模式的組成部分

1. 中介者（Mediator）：定義了物件之間通訊的介面。
2. 具體中介者（Concrete Mediator）：實現了中介者接口，負責協調各個物件之間的溝通。
3. 同事（Colleague）：參與互動的對象，所有同事對像都透過中介者與其他對象通信，而不是直接呼叫彼此的方法。

中介者模式與其他相似模式的區別

中介者模式與一些常見的設計模式有相似之處，但它們的目的和應用場景有所不同：

1. 觀察者模式（Observer Pattern）：

   • 目標：觀察者模式透過訂閱和通知機制實現物件之間的通信，適合用於一對多的關係。
   • 差別：觀察者模式是一種事件驅動的模式，而中介者模式較適合管理多個物件之間的複雜互動邏輯。

2. 命令模式（Command Pattern）：

   • 目標：命令模式將請求封裝為對象，以便於請求的排隊、記錄和撤銷。
   • 差別：命令模式關注的是請求的封裝和處理，而中介者模式側重於物件間的協調與解耦。

3. 橋模式（Bridge Pattern）：

   • 目標：橋模式將抽象部分與實作部分分離，使它們可以獨立變化。
   • 差別：橋模式用於結構上的解耦，而中介者模式用於行為上的解耦。

中介者模式解決了什麼問題？

1. 減少物件之間的耦合：在複雜系統中，如果物件之間直接引用彼此，會導致系統難以維護。中介者模式透過引入中介者對象，將各個對象的依賴關係轉移到中介者身上，減少了對象之間的直接耦合。

2. 簡化物件的互動邏輯：中介者模式將物件之間的互動邏輯集中到一個中介者中，使得各個物件的職責更加單一，只需與中介者互動。

3. 提升系統的擴展性：由於各個物件之間沒有直接依賴關係，新增物件或修改物件的互動邏輯時，只需修改中介者即可，不會影響其他物件。

中介者模式的應用場景

• 聊天系統：在聊天室中，使用者之間的訊息透過一個中介者（如伺服器）進行傳遞，而不是使用者之間直接通訊。
• 表單元件交互：在複雜的UI系統中，表單的各個元件（如按鈕、輸入框）之間的互動可以透過中介者來協調。
• 事件系統：在事件系統中，不同模組之間的事件傳遞可以透過中介者來管理，避免模組之間的直接耦合。

Golang中的中介者模式實現

下面我們透過一個具體的Golang範例，展示如何使用中介者模式來實作一個簡單的聊天系統。

例：聊天室中介者

1. 定義中介者接口

package main 

// Mediator 介面：定義中介者的行為
type Mediator interface { 
	SendMessage(message string, sender Colleague) Register(colleague Colleague) 
}

2. 實現具體中介者

import "fmt"

// ChatMediator 結構體：具體中介者，實作了Mediator 介面
type ChatMediator struct {
	colleagues []Colleague
}

func (c *ChatMediator) Register(colleague Colleague) {
	c.colleagues = append(c.colleagues, colleague)
}

func (c *ChatMediator) SendMessage(message string, sender Colleague) {
	for _, colleague := range c.colleagues {
	 	// 訊息不會發回給發送者自己 
		if colleague != sender { 
			colleague.Receive(message ) 
		} 
	} 
}

3. 定義同事介面

// Colleague 介面：定義同事物件的行為
type Colleague interface {
	Send(message string) Receive(message string)
}

4. 實現具體的同事對象

// User 結構體：具體同事對象，實作了Colleague 介面
type User struct { 
	name string 
	mediator Mediator 
} 

func (u *User) Send(message string) { 
	fmt.Printf("%s 傳送訊息: %s\n", u .name, message) 
	u.mediator.SendMessage(message, u)
} 

func (u *User) Receive(message string) { 
	fmt.Printf("%s 收到訊息: %s\n", u.name, message) 
}

5. 使用中介者模式的範例程式碼

func main() {

	// 建立具體中介者
	chatMediator := &ChatMediator{}

	// 建立使用者（同事物件）
	user1 := &User{name: "Alice", mediator: chatMediator}
	user2 := &User{name: "Bob" , mediator: chatMediator}
	user3 := &User{name: "Eve", mediator: chatMediator}

	// 註冊用戶到中介者
	chatMediator.Register(user1)
	chatMediator.Register(user2)
	chatMediator.Register(user3)

	// 發送訊息1 
	user1.Send("Hello, everyone!")
	user2.Send("Hi Alice!")
}

輸出

Alice 發送訊息: Hello, everyone!
Bob 收到訊息: Hello, everyone!
Eve 收到訊息: Hello, everyone! 
Bob 發送訊息: Hi Alice! 
Alice 收到訊息: Hi Alice! 
Eve 收到訊息: Hi Alice!

程式碼解析

1. Mediator 介面：定義了中介者的行為接口，包括發送訊息和註冊同事對象的方法。
2. ChatMediator 結構體：實現了 Mediator 接口，負責在用戶之間傳遞訊息。
3. Colleague 介面：定義了同事物件的行為接口，包括發送和接收訊息的方法。
4. User 結構體：實現了 Colleague 接口，代表具體的使用者對象，透過中介者發送和接收訊息。
5. main 函數：展示如何使用中介者模式來實現一個簡單的聊天室系統。

實際開發中的應用

中介者模式在實際開發上有廣泛的應用，尤其在需要管理複雜互動的系統中。以下是幾個常見的應用場景：

1. 聊天系統：如上述範例所示，聊天室中的訊息傳遞可以透過中介者實現。
2. UI元件交互：在複雜的UI系統中，各個元件之間的互動可以透過中介者進行協調，避免元件之間的直接依賴。
3. 事件系統：在事件驅動的系統中，中介者模式可以用來管理模組之間的事件傳遞，避免模組之間的耦合。

使用中介者模式的注意事項

1. 中介者的複雜性：雖然中介者模式減少了物件之間的耦合，但也會增加中介者本身的複雜性。設計時應盡量控制中介者的複雜度。
2. 避免過度使用：中介者模式適用於物件之間存在複雜互動的場景。如果物件之間的互動較為簡單，使用中介者模式可能會增加不必要的複雜性。
3. 介面的設計：中介者介面的設計應盡量通用，以便支援不同類型的物件互動。

中介者模式與觀察者模式的對比

總結

中介者模式透過引入一個中介者物件來管理物件之間的交互，減少了物件之間的直接依賴，使系統更加靈活。在Golang中，中介者模式的實作相對簡單，透過介面和結構體的組合即可實現。在實際開發中，中介者模式適用於物件之間存在複雜互動的場景，如聊天系統、UI元件互動和事件系統等。

參考連結

• 設計模式- 中介者模式
• Golang 設計模式