设计模式(023)行为型之中介者模式

本文主要是介绍设计模式(023)行为型之中介者模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

        中介者模式是一种行为型设计模式，用于减少对象之间的直接通信，而是通过一个中介对象来进行间接通信。这种模式有助于减少对象之间的耦合，使得系统更易于维护和扩展。
在中介者模式中，主要有以下几个角色：
① 中介者（Mediator）：定义了一个接口用于各个同事对象之间的通信，并负责实现具体的协调逻辑。
② 具体中介者（ConcreteMediator）：实现了中介者接口，负责协调各个同事对象之间的通信。
③ 同事类（Colleague）：每个同事类都知道中介者对象，并通过中介者对象来通信，而不是直接与其他同事对象通信。
④ 具体同事类（ConcreteColleague）：实现了同事类接口，每个具体同事类都需要知道中介者对象，并通过中介者对象来进行通信。
中介者模式通常应用于多个对象之间存在复杂的交互关系，通过引入中介者对象来简化对象之间的通信，降低耦合度，同时也使得系统更易于理解和扩展。

1、场景设计

实现场景：A、B两个同事通过中介者进行消息收发。

2、C++实现

`Colleague` 是同事类接口，定义了同事对象的基本行为。`ConcreteColleagueA` 和 `ConcreteColleagueB` 是具体的同事类，实现了同事类接口。`Mediator` 是中介者类接口，定义了中介者对象的基本行为。`ConcreteMediator` 是具体的中介者类，负责协调不同同事类之间的通信。在 `main` 函数中，我们创建了中介者对象和两个具体同事对象，并设置了中介者对象的引用，然后通过同事对象发送消息，中介者对象负责转发消息给其他同事对象。 

#include <iostream>
#include <string>
#include <vector>// 前置声明
class Mediator;// 同事类接口
class Colleague {protected:Mediator* mediator;public:Colleague(Mediator* mediator) : mediator(mediator) {}virtual void send(const std::string& message) = 0;virtual void receive(const std::string& message) = 0;
};// 中介者类接口
class Mediator {public:virtual void send(const std::string& message, Colleague* colleague) = 0;
};// 具体同事类A
class ConcreteColleagueA : public Colleague {public:ConcreteColleagueA(Mediator* mediator) : Colleague(mediator) {}void send(const std::string& message) override {mediator->send(message, this);}void receive(const std::string& message) override {std::cout << "ConcreteColleagueA received: " << message << std::endl;}
};// 具体同事类B
class ConcreteColleagueB : public Colleague {public:ConcreteColleagueB(Mediator* mediator) : Colleague(mediator) {}void send(const std::string& message) override {mediator->send(message, this);}void receive(const std::string& message) override {std::cout << "ConcreteColleagueB received: " << message << std::endl;}
};// 具体中介者类
class ConcreteMediator : public Mediator {private:ConcreteColleagueA* colleagueA;ConcreteColleagueB* colleagueB;public:void setColleagueA(ConcreteColleagueA* colleagueA) {this->colleagueA = colleagueA;}void setColleagueB(ConcreteColleagueB* colleagueB) {this->colleagueB = colleagueB;}void send(const std::string& message, Colleague* colleague) override {if (colleague == colleagueA) {colleagueB->receive(message);} else if (colleague == colleagueB) {colleagueA->receive(message);}}
};int main() {ConcreteMediator mediator;ConcreteColleagueA colleagueA(&mediator);ConcreteColleagueB colleagueB(&mediator);mediator.setColleagueA(&colleagueA);mediator.setColleagueB(&colleagueB);colleagueA.send("Hello from colleague A");colleagueB.send("Hi from colleague B");return 0;
}

3、Java实现

`Mediator` 是中介者接口，定义了中介者对象的基本行为。`Colleague` 是同事类抽象类，定义了同事对象的基本行为。`ConcreteColleagueA` 和 `ConcreteColleagueB` 是具体的同事类，实现了同事类抽象类。`ConcreteMediator` 是具体的中介者类，负责协调不同同事类之间的通信。在 `main` 方法中，我们创建了中介者对象和两个具体同事对象，并将同事对象添加到中介者对象中，然后通过同事对象发送消息，中介者对象负责转发消息给其他同事对象。 

package behavioralpattern.mediator;import java.util.ArrayList;
import java.util.List;// 中介者接口
interface Mediator {void sendMessage(String message, Colleague colleague);
}// 同事类抽象类
abstract class Colleague {protected Mediator mediator;public Colleague(Mediator mediator) {this.mediator = mediator;}public abstract void sendMessage(String message);public abstract void receiveMessage(String message);
}// 具体同事类A
class ConcreteColleagueA extends Colleague {public ConcreteColleagueA(Mediator mediator) {super(mediator);}@Overridepublic void sendMessage(String message) {mediator.sendMessage(message, this);}@Overridepublic void receiveMessage(String message) {System.out.println("ConcreteColleagueA received: " + message);}
}// 具体同事类B
class ConcreteColleagueB extends Colleague {public ConcreteColleagueB(Mediator mediator) {super(mediator);}@Overridepublic void sendMessage(String message) {mediator.sendMessage(message, this);}@Overridepublic void receiveMessage(String message) {System.out.println("ConcreteColleagueB received: " + message);}
}// 具体中介者类
class ConcreteMediator implements Mediator {private List<Colleague> colleagues = new ArrayList<>();public void addColleague(Colleague colleague) {colleagues.add(colleague);}@Overridepublic void sendMessage(String message, Colleague colleague) {for (Colleague c : colleagues) {if (c != colleague) {c.receiveMessage(message);}}}
}public class MediatorDemo {public static void main(String[] args) {ConcreteMediator mediator = new ConcreteMediator();ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);mediator.addColleague(colleagueA);mediator.addColleague(colleagueB);colleagueA.sendMessage("Hello from colleague A");colleagueB.sendMessage("Hi from colleague B");}
}

这篇关于设计模式(023)行为型之中介者模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---