什么是中介者模式
中介者模式是一种行为设计模式，它允许将对象之间的通信封装到一个中介者对象中。在这种模式中，对象不再直接相互通信，而是通过中介者进行交互。这可以降低对象之间的耦合度，并使代码更易于维护和扩展。 中介者模式通常用于需要大量对象相互交互的场景，例如GUI应用程序或多人游戏。通过将所有对象的通信集中在中介者中，可以更好地控制和管理系统中的交互行为。此外，中介者模式还可以支持系统中的松耦合设计，从而更容易地扩展和修改系统中的对象和行为。
如何实现中介者模式
中介者模式的实现步骤如下：
- 定义中介者接口：中介者接口定义了各个组件之间通信的协议。
- 定义组件接口：组件接口定义了组件需要实现的方法，以便中介者对象调用。
- 定义具体组件类：实现组件接口中定义的方法，并在需要通信时使用中介者对象调用其他组件的方法。
- 定义具体中介者类：实现中介者接口中定义的协议，并持有所有组件的引用，以便在接收到消息时转发给其他组件。
- 创建组件对象：创建需要进行通信的组件对象，并将它们传递给中介者对象。
- 将中介者对象传递给组件对象：将中介者对象传递给各个组件对象，以便它们在需要通信时调用中介者对象的方法。
- 调用组件方法：在需要通信时，各个组件对象调用中介者对象的方法，以便中介者对象将消息转发给其他组件。
- 修改中介者类：如果需要增加新的组件或修改通信协议，只需要修改中介者类即可。
Tip：中介者模式会增加对象之间的耦合性，因为各个组件对象都需要知道中介者对象的存在。但是，它可以降低系统的复杂度，因为各个组件对象不再需要知道其他组件对象的存在，只需要知道中介者对象即可。此外，中介者模式也可以方便地扩展系统，因为新增加组件或修改通信协议只需要修改中介者类即可。
Java实现 以下是 Java 中介者模式的代码实现：
代码语言：javascript复制// 中介者接口
public interface Mediator {
void sendMessage(String message, Colleague colleague);
}
// 具体中介者
public class ConcreteMediator implements Mediator {
private ColleagueA colleagueA;
private ColleagueB colleagueB;
public void setColleagueA(ColleagueA colleagueA) {
this.colleagueA = colleagueA;
}
public void setColleagueB(ColleagueB colleagueB) {
this.colleagueB = colleagueB;
}
@Override
public void sendMessage(String message, Colleague colleague) {
if (colleague == colleagueA) {
colleagueB.notify(message);
} else {
colleagueA.notify(message);
}
}
}
// 抽象同事类
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void notify(String message);
}
// 具体同事类A
public class ColleagueA extends Colleague {
public ColleagueA(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void notify(String message) {
System.out.println("ColleagueA receive message: " message);
}
}
// 具体同事类B
public class ColleagueB extends Colleague {
public ColleagueB(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void notify(String message) {
System.out.println("ColleagueB receive message: " message);
}
}在这个例子中，Mediator 是中介者接口，定义了 sendMessage 方法。ConcreteMediator 是具体中介者，实现了 sendMessage 方法。Colleague 是抽象同事类，包含一个中介者对象和 send 和 notify 两个抽象方法。ColleagueA 和 ColleagueB 是具体同事类，实现了 send 和 notify 方法。
当 ColleagueA 发送消息时，通过中介者 ConcreteMediator 将消息发送给 ColleagueB。反之亦然。这样，同事类之间不再直接进行交互，而是通过中介者进行交互。
C#实现 以下是 C# 中介者模式的一个简单实现示例：
代码语言：javascript复制using System;
using System.Collections.Generic;
// 抽象中介者类
public abstract class Mediator
{
public abstract void Send(string message, Colleague colleague);
}
// 抽象同事类
public abstract class Colleague
{
protected Mediator mediator;
public Colleague(Mediator mediator)
{
this.mediator = mediator;
}
public virtual void Send(string message)
{
mediator.Send(message, this);
}
public abstract void Notify(string message);
}
// 具体中介者类
public class ConcreteMediator : Mediator
{
private Dictionary<string, Colleague> colleagues = new Dictionary<string, Colleague>();
public override void Send(string message, Colleague colleague)
{
foreach (var col in colleagues.Values)
{
if (col != colleague)
{
col.Notify(message);
}
}
}
public void Register(string name, Colleague colleague)
{
colleagues.Add(name, colleague);
}
}
// 具体同事类
public class ConcreteColleagueA : Colleague
{
public ConcreteColleagueA(Mediator mediator) : base(mediator)
{
}
public override void Notify(string message)
{
Console.WriteLine("同事 A 得到消息：" message);
}
}
// 具体同事类
public class ConcreteColleagueB : Colleague
{
public ConcreteColleagueB(Mediator mediator) : base(mediator)
{
}
public override void Notify(string message)
{
Console.WriteLine("同事 B 得到消息：" message);
}
}
// 客户端代码
class Program
{
static void Main(string[] args)
{
ConcreteMediator mediator = new ConcreteMediator();
ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
mediator.Register("colleagueA", colleagueA);
mediator.Register("colleagueB", colleagueB);
colleagueA.Send("吃饭了吗？");
colleagueB.Send("没有呢，你打算请客？");
Console.ReadKey();
}
}在该示例中，中介者 Mediator 负责协调具体同事类 ConcreteColleagueA 和 ConcreteColleagueB 的通信。当其中一个同事发送消息时，中介者会将消息发送给其他同事，而不是直接将消息发送给目标同事。这样，每个同事都不需要知道其他同事的存在，从而实现了松耦合。
值得注意的是，具体中介者类 ConcreteMediator 必须知道具体同事类的存在，因此需要对每个具体同事类进行注册。这是该模式的一个缺点，因为增加或删除同事类需要修改中介者类，可能会导致系统的维护困难。
总结
中介者模式是一种行为型设计模式，它允许将多个对象间的交互行为集中到一个中介者对象中，从而使得各个对象间的耦合度降低，且易于维护和扩展。中介者模式适用于对象间的交互行为变得复杂时，可以将其抽象为中介者对象，使得各个对象间只需与中介者交互而不需要知道其它对象的存在。中介者模式可以提高系统的灵活性、可维护性和可扩展性。同时，中介者模式也存在一些缺点，如可能导致中介者对象变得过于复杂，且增加了系统的开销。 优点： 1.减少对象间的耦合度，提高系统的灵活性和可维护性； 2.把对象间的交互行为抽象成中介者对象，简化了对象间的交互方式； 3.易于扩展和维护，增加新的对象只需要修改中介者对象即可，无需修改其它对象。
缺点： 1.可能导致中介者对象变得过于复杂，难以维护和扩展； 2.增加了系统的开销，因为中介者对象需要处理其它对象的交互行为； 3.可能降低系统的性能，因为中介者对象需要处理大量的交互行为。
