中介者模式：拆分复杂系统的简单方法

闲谈

2022-11-28 00:33:29

中介者模式：降低耦合度，提高可维护性的关键

了解中介者模式

在现实世界中，中介者扮演着至关重要的角色。从房地产交易中的代理机构到软件开发中的协调器，中介者促进沟通，简化流程。类似地，中介者模式在软件设计中发挥着至关重要的作用，它能够让对象间接通信，从而大幅降低耦合度，提高系统可维护性。

中介者模式的优势

降低耦合度： 对象通过中介者进行交互，无需直接引用，有效降低了耦合度，提高了可维护性。
提高可扩展性： 当系统需要扩展时，仅需修改中介者，而不需要修改其他对象，提升了系统的可扩展性。
简化系统设计： 中介者模式将复杂系统拆分为多个小型模块，简化了系统设计。

中介者模式的工作原理

中介者模式的核心思想是将对象之间的通信集中到一个单独的对象（中介者）中。中介者负责协调对象之间的交互，确保它们以正确的方式进行通信。

代码示例

为了更深入地理解中介者模式，让我们通过一个代码示例来演示它的工作原理：

package main

import "fmt"

// Mediator defines the interface for communication between objects.
type Mediator interface {
	Send(string, string)
}

// ConcreteMediator implements the Mediator interface.
type ConcreteMediator struct {
	colleagues map[string]Colleague
}

// Send sends a message to a colleague.
func (m *ConcreteMediator) Send(sender, message string) {
	fmt.Printf("%s: %s\n", sender, message)
	for name, colleague := range m.colleagues {
		if name != sender {
			colleague.Receive(sender, message)
		}
	}
}

// Colleague defines the interface for objects that can communicate with each other.
type Colleague interface {
	Send(string)
	Receive(string, string)
}

// ConcreteColleagueA implements the Colleague interface.
type ConcreteColleagueA struct {
	mediator Mediator
}

// Send sends a message to the mediator.
func (c *ConcreteColleagueA) Send(message string) {
	c.mediator.Send("ConcreteColleagueA", message)
}

// Receive receives a message from the mediator.
func (c *ConcreteColleagueA) Receive(sender, message string) {
	fmt.Printf("ConcreteColleagueA: Received message from %s: %s\n", sender, message)
}

// ConcreteColleagueB implements the Colleague interface.
type ConcreteColleagueB struct {
	mediator Mediator
}

// Send sends a message to the mediator.
func (c *ConcreteColleagueB) Send(message string) {
	c.mediator.Send("ConcreteColleagueB", message)
}

// Receive receives a message from the mediator.
func (c *ConcreteColleagueB) Receive(sender, message string) {
	fmt.Printf("ConcreteColleagueB: Received message from %s: %s\n", sender, message)
}

func main() {
	mediator := &ConcreteMediator{
		colleagues: make(map[string]Colleague),
	}

	colleagueA := &ConcreteColleagueA{
		mediator: mediator,
	}

	colleagueB := &ConcreteColleagueB{
		mediator: mediator,
	}

	mediator.colleagues["ConcreteColleagueA"] = colleagueA
	mediator.colleagues["ConcreteColleagueB"] = colleagueB

	colleagueA.Send("Hello, ConcreteColleagueB!")
	colleagueB.Send("Hello, ConcreteColleagueA!")
}

输出结果

ConcreteColleagueA: Hello, ConcreteColleagueB!
ConcreteColleagueB: Received message from ConcreteColleagueA: Hello, ConcreteColleagueB!
ConcreteColleagueB: Hello, ConcreteColleagueA!
ConcreteColleagueA: Received message from ConcreteColleagueB: Hello, ConcreteColleagueA!

总结

中介者模式是一种有效的设计模式，它允许对象间接通信，降低耦合度，提高可维护性。通过将对象之间的交互集中到一个中介者中，我们可以构建更灵活、更易于扩展和维护的系统。