一、中介者模式概述

1.1 什么是中介者模式

中介者模式，又被称为调停者模式，是一种行为型设计模式，其核心思想是通过引入一个中介对象来封装一系列对象之间的交互。这种模式使得各对象不需要显式地相互引用，从而降低了它们之间的耦合度和依赖性，使得系统更易于维护和扩展。

中介者模式的主要角色包括：

抽象中介者（Mediator）：定义中介者接口，声明各种业务方法。
具体中介者（Concrete Mediator）：实现抽象中介者接口，负责与各个同事对象之间的通信和协调。
抽象同事类（Colleague）：定义同事类接口，声明一些抽象方法，用于与中介者进行通信。
当系统中的对象之间的关系变得复杂，例如形成网状结构时，中介者模式尤为有用。通过引入中介者，可以将原本复杂的网状结构转化为更为清晰的星型结构，使得各个对象之间的交互更加明确和简单。

举个例子，考虑一个团队协作的场景，团队成员之间可能存在大量的沟通和协作。如果不使用中介者模式，那么每个成员都可能需要知道与其他所有成员的联系方式，这样当有新的成员加入或某个成员离开时，整个系统的复杂度都会增加。而使用中介者模式后，团队成员只需要与中介者通信，由中介者负责调度和协调各个成员之间的交互。

1.2 简单实现中介者模式

中介者模式是一种行为型设计模式，它通过引入一个中介者对象来协调多个对象之间的交互。以下是一个简单的Java实现：

首先，创建一个抽象的中介者类（Mediator）：

public abstract class Mediator {protected List<Colleague> colleagues = new ArrayList<>();public void addColleague(Colleague colleague) {colleagues.add(colleague);}public void removeColleague(Colleague colleague) {colleagues.remove(colleague);}public abstract void sendMessage(String message, Colleague sender);
}

然后，创建一个具体的中介者类（ConcreteMediator）：

public class ConcreteMediator extends Mediator {@Overridepublic void sendMessage(String message, Colleague sender) {for (Colleague colleague : colleagues) {if (colleague != sender) {colleague.receiveMessage(message, sender);}}}
}

接下来，创建抽象的同事类（Colleague）：

public abstract class Colleague {protected Mediator mediator;public Colleague(Mediator mediator) {this.mediator = mediator;mediator.addColleague(this);}public abstract void sendMessage(String message);public abstract void receiveMessage(String message, Colleague sender);
}

最后，创建具体的同事类（ConcreteColleagueA和ConcreteColleagueB）

public class ConcreteColleagueA extends Colleague {public ConcreteColleagueA(Mediator mediator) {super(mediator);}@Overridepublic void sendMessage(String message) {System.out.println("同事A发送消息：" + message);mediator.sendMessage(message, this);}@Overridepublic void receiveMessage(String message, Colleague sender) {System.out.println("同事A收到来自" + sender + "的消息：" + message);}
}public class ConcreteColleagueB extends Colleague {public ConcreteColleagueB(Mediator mediator) {super(mediator);}@Overridepublic void sendMessage(String message) {System.out.println("同事B发送消息：" + message);mediator.sendMessage(message, this);}@Overridepublic void receiveMessage(String message, Colleague sender) {System.out.println("同事B收到来自" + sender + "的消息：" + message);}
}

现在，你可以创建中介者和同事对象，并测试它们之间的交互：

public class Main {public static void main(String[] args) {Mediator mediator = new ConcreteMediator();Colleague colleagueA = new ConcreteColleagueA(mediator);Colleague colleagueB = new ConcreteColleagueB(mediator);colleagueA.sendMessage("你好，同事B！");colleagueB.sendMessage("你好，同事A！");}
}

运行上述代码，你将看到以下输出：

同事A发送消息：你好，同事B！
同事B收到来自同事A的消息：你好，同事B！
同事B发送消息：你好，同事A！
同事A收到来自同事B的消息：你好，同事A！

1.3 使用中介者模式的注意事项

• 1、中介者模式适用于多个对象之间存在复杂的交互关系，需要协调和统一管理的情况。

• 2、中介者模式会增加系统的复杂性和维护成本，因此应该谨慎使用。

• 3、中介者模式可能会导致性能问题，因为所有的消息都需要通过中介者传递。

• 4、中介者模式应该尽量避免过多的中介者对象，否则会导致系统更加复杂。

• 5、在设计中介者模式时，应该考虑到系统的可扩展性和灵活性，以便在未来可以方便地添加或删除对象。

• 6、中介者模式应该避免过度依赖中介者对象，否则会导致系统变得脆弱和不可维护

二、中介者模式的用途

• 1、简化对象之间的关系：中介者模式能够简化系统内各个对象之间的相互关系，将原本复杂的网状结构转变为相对简单的线性结构。

• 2、降低系统的复杂性：通过引入中介者对象，可以减少子类生成，降低了系统的复杂性和维护成本。

• 3、提高系统的灵活性和可扩展性：当需要增加新的功能或者删除某个对象时，只需要对中介者进行修改，而不需要修改其他对象，从而提高了系统的灵活性和可扩展性。

• 4、封装转换规则：中介者模式能够将对象间的交互规则进行封装，使得对象间的交互更加清晰。

三、中介者模式实现方式

3.1 使用接口和类的方式

通过定义一个中介者接口，然后创建具体的中介者类来实现中介者模式。

// 中介者接口
interface Mediator {void send(String message, Colleague colleague);
}// 具体中介者类
class ConcreteMediator implements Mediator {private List<Colleague> colleagues = new ArrayList<>();public void addColleague(Colleague colleague) {colleagues.add(colleague);}public void send(String message, Colleague colleague) {for (Colleague c : colleagues) {if (c != colleague) {c.receive(message);}}}
}// 同事类
abstract class Colleague {protected Mediator mediator;public Colleague(Mediator mediator) {this.mediator = mediator;mediator.addColleague(this);}public abstract void send(String message);public abstract void receive(String message);
}

3.2 使用抽象工厂模式的方式

通过定义一个抽象工厂类来创建具体的中介者对象，然后在具体的工厂类中实现中介者对象的创建。

// 抽象工厂类
abstract class AbstractFactory {public abstract Mediator createMediator();
}// 具体工厂类
class ConcreteFactory extends AbstractFactory {@Overridepublic Mediator createMediator() {return new ConcreteMediator();}
}

3.3 使用单例模式的方式

通过定义一个中介者类，并使用单例模式来确保整个系统中只有一个中介者对象。

// 中介者类
class Mediator {private static Mediator instance;private List<Colleague> colleagues = new ArrayList<>();private Mediator() {}public static Mediator getInstance() {if (instance == null) {instance = new Mediator();}return instance;}public void addColleague(Colleague colleague) {colleagues.add(colleague);}public void send(String message, Colleague colleague) {for (Colleague c : colleagues) {if (c != colleague) {c.receive(message);}}}
}