Claude3 Opus
中介者模式（Mediator Pattern）是一种行为型设计模式，用于降低多个对象之间的耦合性，并且将它们的通信集中管理和控制。中介者模式通过引入一个中介对象，使各个对象之间不再直接相互引用，而是通过中介者对象进行消息传递。
在中介者模式中，各个对象可以通过中介者对象进行交互，而不需要知道其它对象的具体细节。中介者将对象之间的交互封装在中介者对象中，使得对象之间的通信更加简单和可控。
使用中介者模式可以有以下几个优点：
1. 减少对象之间的依赖：通过引入中介者对象，各个对象不再直接相互引用，减少了对象之间的依赖关系，使得系统结构更加灵活和可扩展。
2. 集中控制通信逻辑：中介者对象负责管理和控制对象之间的通信，统一处理对象之间的交互逻辑。这样可以将复杂的交互逻辑集中在中介者对象中，使得代码更加清晰和易于维护。
3. 解耦对象间的关系：对象之间不再直接相互引用，而是通过中介者对象进行通信。这样可以将对象的关系解耦，使得每个对象都可以独立地进行改变和扩展，而不会对其它对象产生影响。
在Java中，可以使用接口或抽象类来定义中介者对象，并在其中定义各个对象之间的交互方法。具体的中介者类可以实现该接口或继承该抽象类。
同时，各个对象需要持有中介者对象的引用，在需要与其它对象进行通信时，通过调用中介者对象的方法来实现交互。
这样，通过中介者模式，可以使得对象之间的通信变得简单和可控，降低系统的复杂性，提高代码的可读性和可维护性。
讯飞星火
中介者模式（Mediator Pattern）是一种行为设计模式，它允许对象之间通过一个中介对象进行通信，从而减少它们之间的直接交互。这种模式通常用于实现一组对象之间的松耦合，使得这些对象可以独立地改变和复用。
以下是一个简单的Java中介者模式示例：
// 中介者接口
interface Mediator {
void send(String message, Colleague colleague);
}
// 同事类接口
interface Colleague {
void setMediator(Mediator mediator);
void receive(String message);
}
// 具体同事类A
class ConcreteColleagueA implements Colleague {
private Mediator mediator;
@Override
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
@Override
public void receive(String message) {
System.out.println("同事A收到消息： " + message);
}
public void send(String message) {
mediator.send(message, this);
}
}
// 具体同事类B
class ConcreteColleagueB implements Colleague {
private Mediator mediator;
@Override
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
@Override
public void receive(String message) {
System.out.println("同事B收到消息： " + message);
}
public void send(String message) {
mediator.send(message, this);
}
}
// 具体中介者类
class ConcreteMediator implements Mediator {
private ConcreteColleagueA colleagueA;
private ConcreteColleagueB colleagueB;
public void setColleagueA(ConcreteColleagueA colleagueA) {
this.colleagueA = colleagueA;
}
public void setColleagueB(ConcreteColleagueB colleagueB) {
this.colleagueB = colleagueB;
}
@Override
public void send(String message, Colleague colleague) {
if (colleague == colleagueA) {
colleagueB.receive(message);
} else {
colleagueA.receive(message);
}
}
}
// 客户端代码
public class MediatorPatternDemo {
public static void main(String[] args) {
ConcreteMediator mediator = new ConcreteMediator();
ConcreteColleagueA colleagueA = new ConcreteColleagueA();
ConcreteColleagueB colleagueB = new ConcreteColleagueB();
mediator.setColleagueA(colleagueA);
mediator.setColleagueB(colleagueB);
colleagueA.setMediator(mediator);
colleagueB.setMediator(mediator);
colleagueA.send("你好，同事B");
colleagueB.send("你好，同事A");
}
}
在这个示例中，我们定义了一个中介者接口Mediator和一个同事类接口Colleague。然后，我们创建了两个具体的同事类ConcreteColleagueA和ConcreteColleagueB，以及一个具体的中介者类ConcreteMediator。客户端代码创建了中介者和同事对象的实例，并将它们关联起来。当一个同事对象发送消息时，中介者负责将消息转发给另一个同事对象。这样，同事对象之间不需要直接相互引用，从而实现了松耦合。
GPT-4o (OpenAI)
探索Java设计模式：深入理解中介者模式
在软件开发中，设计模式是为解决常见设计问题而提出的通用解决方案。中介者模式（Mediator Pattern）就是其中一种，它在处理对象交互中扮演了重要角色。本文将详解Java中的中介者模式，带你了解它的定义、应用场景、优缺点以及具体实现方式。
什么是中介者模式？
中介者模式是一种行为型设计模式，它定义了一个对象（中介者）来封装一系列对象之间的交互。中介者使各对象不需要相互引用，从而降低它们之间的耦合，提高系统的扩展性和维护性。
中介者模式的定义：
中介者模式的定义可以简单理解为：用一个中介对象封装一系列的对象交互。中介者使对象通过中介者进行通信，从而避免了对象之间的显式引用。
示意图：
+---------+ +---------+ +---------+
| Client1 | -------> | Mediator| <------- | Client2 |
+---------+ +---------+ +---------+
^ ^
| |
+---------------------------------------+
应用场景
中介者模式适用于以下场景：
1. 对象之间存在复杂的引用关系： 当对象之间的交互逻辑复杂且多对多关系明显时，中介者可以简化这些关系。
2. 需要解耦对象关系： 将每个对象的交互通过中介者进行，避免直接引用和复杂的依赖关系。
3. 希望集中控制交互： 集中管理交互逻辑，便于修改和维护。
优缺点分析
优点
1. 降低类之间的耦合： 类之间不再直接相互依赖，而是通过中介者进行通信，降低了系统的复杂性。
2. 集中控制交互： 将交互逻辑集中在中介者中，便于优化和维护。
3. 提高系统灵活性： 新增或修改任何对象时，只需改变与中介者的交互即可，不需要改变其他对象。
缺点
1. 中介者可能成为单点瓶颈： 中介者集中管理所有交互逻辑，可能会导致其变为整个系统的性能瓶颈或故障点。
2. 复杂性转移： 尽管减少了对象直接耦合，但交互逻辑聚集在中介者中，如果不加控制，可能导致中介者自身变得复杂。
具体实现
我们通过一个简单的聊天应用案例来展示中介者模式的实现。
假设我们有多个用户（User），他们通过一个聊天服务器（ChatMediator）进行通信。
1. 定义中介者接口和具体实现：
// Mediator接口
public interface ChatMediator {
void sendMessage(String msg, User user);
void addUser(User user);
}
// 具体的中介者实现类
public class ChatMediatorImpl implements ChatMediator {
private List<User> users;
public ChatMediatorImpl() {
this.users = new ArrayList<>();
}
@Override
public void addUser(User user) {
this.users.add(user);
}
@Override
public void sendMessage(String msg, User user) {
for (User u : users) {
// 消息不会发送给发送者自己
if (u != user) {
u.receive(msg);
}
}
}
}
2. 定义用户类：
// 用户类
public abstract class User {
protected ChatMediator mediator;
protected String name;
public User(ChatMediator mediator, String name){
this.mediator = mediator;
this.name = name;
}
public abstract void send(String msg);
public abstract void receive(String msg);
}
package mediator;
// 具体的用户实现类
public class UserImpl extends User {
public UserImpl(ChatMediator mediator, String name) {
super(mediator, name);
}
@Override
public void send(String msg) {
System.out.println(this.name + ": Sending Message = " + msg);
mediator.sendMessage(msg, this);
}
@Override
public void receive(String msg) {
System.out.println(this.name + ": Received Message = " + msg);
}
}我们已经定义了中介者接口 ChatMediator 及其具体实现 ChatMediatorImpl，并且定义了一个抽象的 User 类及其具体实现 UserImpl。
3. 测试中介者模式
我们创建一个简单的客户端代码来测试中介者模式：
package mediator;
public class MediatorPatternDemo {
public static void main(String[] args) {
ChatMediator mediator = new ChatMediatorImpl();
User user1 = new UserImpl(mediator, "Alice");
User user2 = new UserImpl(mediator, "Bob");
User user3 = new UserImpl(mediator, "Charlie");
User user4 = new UserImpl(mediator, "David");
mediator.addUser(user1);
mediator.addUser(user2);
mediator.addUser(user3);
mediator.addUser(user4);
user1.send("Hello, everyone!");
}
}完整代码
为了方便起见，以下是完整的代码放在一起：
package mediator;
import java.util.ArrayList;
import java.util.List;
// Mediator接口
public interface ChatMediator {
void sendMessage(String msg, User user);
void addUser(User user);
}
// 具体的中介者实现类
public class ChatMediatorImpl implements ChatMediator {
private List<User> users;
public ChatMediatorImpl() {
this.users = new ArrayList<>();
}
@Override
public void addUser(User user) {
this.users.add(user);
}
@Override
public void sendMessage(String msg, User user) {
for (User u : users) {
// 消息不会发送给发送者自己
if (u != user) {
u.receive(msg);
}
}
}
}
// 用户类
public abstract class User {
protected ChatMediator mediator;
protected String name;
public User(ChatMediator mediator, String name){
this.mediator = mediator;
this.name = name;
}
public abstract void send(String msg);
public abstract void receive(String msg);
}
// 具体的用户实现类
public class UserImpl extends User {
public UserImpl(ChatMediator mediator, String name) {
super(mediator, name);
}
@Override
public void send(String msg) {
System.out.println(this.name + ": Sending Message = " + msg);
mediator.sendMessage(msg, this);
}
@Override
public void receive(String msg) {
System.out.println(this.name + ": Received Message = " + msg);
}
}
// 测试中介者模式
public class MediatorPatternDemo {
public static void main(String[] args) {
ChatMediator mediator = new ChatMediatorImpl();
User user1 = new UserImpl(mediator, "Alice");
User user2 = new UserImpl(mediator, "Bob");
User user3 = new UserImpl(mediator, "Charlie");
User user4 = new UserImpl(mediator, "David");
mediator.addUser(user1);
mediator.addUser(user2);
mediator.addUser(user3);
mediator.addUser(user4);
user1.send("Hello, everyone!");
}
}输出
运行上述 MediatorPatternDemo 类，输出结果可能如下：
Alice: Sending Message = Hello, everyone!
Bob: Received Message = Hello, everyone!
Charlie: Received Message = Hello, everyone!
David: Received Message = Hello, everyone!
总结
中介者模式在很多复杂系统中的应用非常广泛，尤其是在对象关系密集和复杂交互逻辑的场景中。它通过引入一个中介者对象，使各个对象互相协作而无需直接通信，从而降低耦合度，提高系统可维护性并增强其扩展性。
在本文中，我们通过一个简单的聊天应用案例展示了中介者模式在Java中的实现，这样的实现能有效解耦用户之间的直接交互，并集中管理消息的传递和处理。尽管中介者模式能够带来诸多好处，但也需要注意由于中介者集中管理交互，可能会导致其本身变得复杂或成为性能瓶颈的问题。因此在实际应用中，需要综合考虑系统的具体需求和可能的性能问题。
最后，熟练掌握中介者模式及其应用场景可以有效提升你的设计能力，使你在复杂系统的设计中游刃有余。
完整代码示例
为了让你更好地理解中介者模式，这里提供一个完整的实现代码：
import java.util.ArrayList;
import java.util.List;
interface ChatMediator {
void sendMessage(String msg, User user);
void addUser(User user);
}
class ChatMediatorImpl implements ChatMediator {
private List<User> users;
public ChatMediatorImpl() {
this.users = new ArrayList<>();
}
@Override
public void addUser(User user) {
this.users.add(user);
}
@Override
public void sendMessage(String msg, User user) {
for (User u : users) {
// 消息不会发送给发送者自己
if (u != user) {
u.receive(msg);
}
}
}
}
abstract class User {
protected ChatMediator mediator;
protected String name;
public User(ChatMediator mediator, String name) {
this.mediator = mediator;
this.name = name;
}
public abstract void send(String msg);
public abstract void receive(String msg);
}
class UserImpl extends User {
public UserImpl(ChatMediator mediator, String name) {
super(mediator, name);
}
@Override
public void send(String msg) {
System.out.println(this.name + ": Sending Message = " + msg);
mediator.sendMessage(msg, this);
}
@Override
public void receive(String msg) {
System.out.println(this.name + ": Received Message: " + msg);
}
}
public class MediatorPatternDemo {
public static void main(String[] args) {
ChatMediator mediator = new ChatMediatorImpl();
User user1 = new UserImpl(mediator, "User1");
User user2 = new UserImpl(mediator, "User2");
User user3 = new UserImpl(mediator, "User3");
User user4 = new UserImpl(mediator, "User4");
mediator.addUser(user1);
mediator.addUser(user2);
mediator.addUser(user3);
mediator.addUser(user4);
user1.send("Hi All");
}
}在这个示例中，`ChatMediatorImpl` 扮演了中介者的角色，它负责管理多个 User 的消息传递和处理。用户通过中介者来发送和接收消息，有效地解耦了用户之间的直接互动。
希望这个例子能帮助你深入理解中介者模式，并能在实际项目中灵活应用该模式解决复杂对象交互问题。
通义千问2.5
中介者模式（Mediator Pattern）是行为型设计模式之一。它用于定义一个对象来封装一系列对象交互的方式，从而降低各个对象之间的耦合度。中介者模式将原本分布于多个对象间的一系列职责集中到一个中介对象中，使得不同类间的交互逻辑更加清晰，同时也便于维护和管理。
用途
- 当系统中的对象之间存在复杂的引用关系时，使用中介者模式可以减少对象间的直接依赖。
- 当一组对象需要相互作用，而这种交互逻辑过于复杂时，可以使用中介者模式来简化它们的交互。
组成部分
- 抽象中介者 (Mediator)：定义了中介者的接口，用于各个同事对象之间的通信。
- 具体中介者 (Concrete Mediator)：实现抽象中介者定义的方法，协调各同事对象的交互。
- 抽象同事类 (Colleague)：定义了同事类的接口，同事对象只知道中介者对象，并通过它与其他同事对象通信。
- 具体同事类 (Concrete Colleague)：实现抽象同事类定义的行为，当需要和其他同事对象通信时，将请求发送给中介者对象。
示例代码
以下是一个简单的中介者模式的示例，展示了两个同事类通过中介者进行通信：
// 抽象中介者
interface Mediator {
void send(String msg, Colleague colleague);
}
// 具体中介者
class ConcreteMediator implements Mediator {
private Colleague colleague1;
private Colleague colleague2;
public void setColleague1(Colleague colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(Colleague colleague2) {
this.colleague2 = colleague2;
}
@Override
public void send(String msg, Colleague colleague) {
if (colleague == colleague1) {
colleague2.notify(msg);
} else {
colleague1.notify(msg);
}
}
}
// 抽象同事类
interface Colleague {
void send(String msg);
void notify(String msg);
}
// 具体同事类
class ConcreteColleague1 implements Colleague {
private Mediator mediator;
public ConcreteColleague1(Mediator mediator) {
this.mediator = mediator;
}
@Override
public void send(String msg) {
System.out.println("Colleague1 sends: " + msg);
mediator.send(msg, this);
}
@Override
public void notify(String msg) {
System.out.println("Colleague1 gets: " + msg);
}
}
class ConcreteColleague2 implements Colleague {
private Mediator mediator;
public ConcreteColleague2(Mediator mediator) {
this.mediator = mediator;
}
@Override
public void send(String msg) {
System.out.println("Colleague2 sends: " + msg);
mediator.send(msg, this);
}
@Override
public void notify(String msg) {
System.out.println("Colleague2 gets: " + msg);
}
}在这个例子中，ConcreteMediator负责处理ConcreteColleague1和ConcreteColleague2之间的通信，而同事类之间并不直接通信，而是通过中介者进行通信，这样就降低了同事类之间的耦合。
腾讯元宝
中介者模式（Mediator Pattern）是一种行为设计模式，它允许你在多个对象之间定义松散耦合的交互。通过引入一个中介者对象，你可以将对象之间的直接交互替换为通过中介者的间接交互。这样可以降低系统的复杂性，提高可维护性和可扩展性。
中介者模式的主要角色
- 抽象中介者（Mediator）：定义一个接口，用于协调各个同事对象之间的交互。
- 具体中介者（ConcreteMediator）：实现抽象中介者接口，负责实际协调各个同事对象之间的交互。
- 抽象同事类（Colleague）：定义一个接口，表示与中介者进行交互的对象。
- 具体同事类（ConcreteColleague）：实现抽象同事类接口，与中介者进行具体的交互。
中介者模式的优点
- 降低了对象之间的耦合度，使得对象更容易复用和修改。
- 将对象之间的交互逻辑集中在一个中介者中，便于维护和扩展。
- 可以减少系统中对象的数量，降低系统的复杂性。
中介者模式的缺点
- 增加了中介者对象的复杂性，需要考虑所有可能的交互情况。
- 如果系统中的交互关系发生变化，可能需要修改中介者的实现。
示例代码
以下是一个简单的中介者模式的示例代码：
// 抽象中介者
interface Mediator {
void register(Colleague colleague);
void send(String message, Colleague sender);
}
// 具体中介者
class ConcreteMediator implements Mediator {
private List<Colleague> colleagues = new ArrayList<>();
@Override
public void register(Colleague colleague) {
colleagues.add(colleague);
}
@Override
public void send(String message, Colleague sender) {
for (Colleague colleague : colleagues) {
if (colleague != sender) {
colleague.receive(message);
}
}
}
}
// 抽象同事类
abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void receive(String message);
}
// 具体同事类A
class ConcreteColleagueA extends Colleague {
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
System.out.println("ConcreteColleagueA 发送消息: " + message);
mediator.send(message, this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleagueA 收到消息: " + message);
}
}
// 具体同事类B
class ConcreteColleagueB extends Colleague {
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
System.out.println("ConcreteColleagueB 发送消息: " + message);
mediator.send(message, this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleagueB 收到消息: " + message);
}
}
// 测试代码
public class MediatorPatternTest {
public static void main(String[] args) {
Mediator mediator = new ConcreteMediator();
Colleague colleagueA = new ConcreteColleagueA(mediator);
Colleague colleagueB = new ConcreteColleagueB(mediator);
mediator.register(colleagueA);
mediator.register(colleagueB);
colleagueA.send("Hello, ColleagueB!");
colleagueB.send("Hello, ColleagueA!");
}
}在这个示例中，ConcreteMediator 是具体中介者，负责协调 ConcreteColleagueA 和 ConcreteColleagueB 之间的交互。当一个同事对象发送消息时，它会通过中介者将消息传递给其他同事对象。
商量
中介者模式（Mediator Pattern）是一种结构型设计模式，它旨在降低多个对象之间的直接耦合关系，而是让它们通过一个中介者对象来通信。这种模式尤其适用于那些一个对象的状态改变会要求多个其他对象相应改变的场景。
中介者模式的核心组件包括：
1. 中介者（Mediator）: 中介者接口定义了一个联络方法，同事对象可以通过该方法与其他同事通信。中介者接口可能会被一个或多个具体中介者实现所实现，负责风协同事对象之间的通信。
2. 同事类（Colleague）: 同事类定义了一个同事对象必须了解其同事对象的接口。通常情况下，同事对象只能通过中介者来与其他同事通信，而不能直接进行通信。
3. 具体同事类（Concrete Colleague）: 实现或继承了同事类，并且依赖于具体中介者来完成它们的工作。
使用中介者模式的优势：
- 降低耦合度：中介者模式通过把对象之间的直接引用改变为通过一个中介者对象进行引用，降低了各个同事对象之间的耦合度。
- 易于维护：当某个同事对象的行为发生变化时，只需要在中介者中更新相应的策略即可，其他同事对象不需要修改。
- 系统的灵活性和可扩展性增强：新的同事对象可以被添加进来，而且不会影响到其他的同事对象，只需在中介者中注册即可。
中介者模式的缺点：
- 增加了系统中类的数量：中介者模式的引入可能会增加系统中类的数量，使得系统复杂度上升。
- 可能成为性能瓶颈：如果中介者处理消息的效率不够高，它就可能成为应用程序的性能瓶颈。
示例场景：
假设我们有一个聊天室的应用，当用户在该聊天室内发送消息时，所有在该聊天室内的其他用户都应该能够收到消息。在这个场景中，聊天室充当了中介者的角色，而用户则是同事对象。
在Java中实现中介者模式，可以按照如下步骤进行：
1. 定义中介者接口和具体的中介者类。
2. 定义同事类接口和具体的同事类，确保同事类中包含对中介者的引用。
3. 在具体同事类中，任何需要与其他同事通信的行为都通过中介者来间接完成。
中介者模式在实际的软件开发中被广泛应用，如窗口管理系统、聊天应用、消息中间件等。
文心大模型4.0 Turbo
Java设计模式中的中介者模式（Mediator Pattern）是一种行为设计模式，主要用于降低多个对象之间的交互复杂度，通过引入一个中介者对象来管理这些对象之间的通信，从而减少对象间的直接依赖。以下是对中介者模式的详细解析：
一、定义与特点
中介者模式定义了一个中介对象来封装一系列的对象交互，使各个对象不需要显式地相互引用，从而使其耦合松散，并且可以独立地改变它们之间的交互。该模式的关键在于将对象之间的交互封装在一个中介者对象内，这样可以将原本错综复杂的多对多交互转化为简单的中介者与各个对象之间的一对多交互。
二、结构与角色
中介者模式主要包含以下几个角色：
- 抽象中介者（Mediator）：定义了同事对象到中介者对象的接口，用于同事对象之间的通信。
- 具体中介者（Concrete Mediator）：实现了抽象中介者接口，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用。
- 抽象同事类（Colleague）：定义了同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
- 具体同事类（Concrete Colleague）：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
三、优缺点
优点
- 降低类的复杂度：将一对多转化成了一对一，简化了对象之间的交互关系。
- 解耦：各个类之间的解耦，提高了系统的可维护性。
- 易于维护和扩展：当需要添加新的同事类或修改同事类的行为时，通常只需要修改中介者类，而不必改动其他同事类。
- 符合迪米特法则：类之间各司其职，降低了对象之间的耦合性。
缺点
- 中介者可能会变得庞大复杂：如果系统中同事对象的数量很多，中介者类可能会变得非常大和复杂，因为它需要管理所有同事对象的交互。
- 可能引入新的依赖：虽然减少了同事对象间的直接依赖，但同事对象对中介者的依赖可能会成为新的单点故障。
- 可能增加理解难度：对于新加入项目的人来说，理解中介者模式以及整个系统架构可能会更加困难。
四、适用场景
- 系统中对象之间存在复杂的引用关系：当对象之间的依赖关系结构混乱且难以复用该对象时，可以使用中介者模式来简化它们之间的交互。
- 希望减少对象间的直接通信：使得对象之间松耦合，提高系统的灵活性。
- 需要简化和标准化对象间的通信机制：通过中介者来统一管理对象间的通信，使得通信过程更加清晰和可控。
五、实例应用
在实际项目中，中介者模式有着广泛的应用，例如：
- MVC框架：在MVC（Model-View-Controller）框架中，控制器（Controller）就充当了模型（Model）和视图（View）之间的中介者角色。
- 聊天室程序：用户之间的消息交流通过聊天室进行，聊天室充当了用户之间的中介者角色。
- 请假审批系统：员工、经理和人事部门之间的请假审批流程可以通过中介者模式来管理，降低它们之间的耦合度。
通过以上分析可以看出，中介者模式是一种强大的设计模式，可以有效地降低系统对象之间的耦合度并提高系统的可维护性和灵活性。然而在使用时也需要注意其可能带来的复杂性和维护性问题。
DeepSeek-V2
中介者模式（Mediator Pattern）是一种行为设计模式，它通过引入一个中介者对象来封装一系列对象之间的交互，从而使得这些对象不需要显式地相互引用，从而降低它们之间的耦合度。中介者模式有助于减少系统中对象之间的直接通信，使得系统更易于维护和扩展。
中介者模式的主要角色
-
中介者（Mediator）：定义一个接口用于与各同事对象（Colleague）通信。
-
具体中介者（Concrete Mediator）：实现中介者接口，协调各个同事对象，管理它们之间的交互。
-
同事类（Colleague）：每个同事类都知道它的中介者对象，并且与中介者通信，而不是与其他同事类直接通信。
-
具体同事类（Concrete Colleague）：实现同事类的接口，通过中介者与其他同事类交互。
示例代码
下面是一个简单的Java示例，展示了如何使用中介者模式。
1. 定义中介者接口
public interface Mediator {
void sendMessage(String message, Colleague colleague);
}2. 定义同事类
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void receive(String message);
}3. 定义具体同事类
public class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleague1 received: " + message);
}
}
public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleague2 received: " + message);
}
}4. 定义具体中介者
public class ConcreteMediator implements Mediator {
private ConcreteColleague1 colleague1;
private ConcreteColleague2 colleague2;
public void setColleague1(ConcreteColleague1 colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(ConcreteColleague2 colleague2) {
this.colleague2 = colleague2;
}
@Override
public void sendMessage(String message, Colleague colleague) {
if (colleague == colleague1) {
colleague2.receive(message);
} else {
colleague1.receive(message);
}
}
}5. 客户端代码
public class Client {
public static void main(String[] args) {
ConcreteMediator mediator = new ConcreteMediator();
ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
mediator.setColleague1(colleague1);
mediator.setColleague2(colleague2);
colleague1.send("Hello from Colleague1");
colleague2.send("Hi from Colleague2");
}
}总结
中介者模式通过引入一个中介者对象，将系统中对象之间的复杂交互关系简化为对象与中介者之间的交互，从而降低了系统的复杂性，提高了系统的可维护性和可扩展性。在实际开发中，中介者模式常用于解决多个对象之间相互引用的问题，特别是在对象之间交互复杂的情况下。
Kimi
中介者模式（Mediator Pattern）是一种行为设计模式，它定义了一个中介对象来封装一系列对象之间的交互。中介者模式使各对象不需要显示地相互引用，从而使耦合度降低，而且可以独立地改变它们之间的交互。
基本概念
- 中介者（Mediator）：定义了对象间的通信方式，协调多个同事对象之间的交互。
- 同事对象（Colleague）：知道中介者对象，通过它与其他同事对象通信，但不知道其他同事对象。
角色
- 中介者接口（Mediator）：定义了同事对象与中介者之间的通信协议。
- 具体中介者（ConcreteMediator）：实现了中介者接口，协调各个具体同事对象之间的交互。
- 同事对象接口（Colleague）：定义了同事对象与中介者之间的通信协议。
- 具体同事对象（ConcreteColleague）：实现了同事对象接口，与其他同事对象通信。
优点
- 降低耦合度：减少了对象之间的依赖关系，对象之间的交互通过中介者完成。
- 提高代码的可维护性：对象之间的交互逻辑集中在中介者中，修改交互逻辑时不需要修改对象本身。
- 易于扩展：新增对象时，只需要实现同事对象接口并注册到中介者即可。
缺点
- 中介者对象复杂度增加：中介者对象可能变得复杂，因为它需要处理所有对象之间的交互。
示例
假设我们有一个聊天室系统，用户可以发送消息给其他用户。使用中介者模式，我们可以定义一个聊天室类作为中介者，用户类作为同事对象。
// 同事对象接口
interface ChatUser {
void receive(String message);
void setMediator(ChatRoom mediator);
}
// 具体同事对象
class User implements ChatUser {
private String name;
private ChatRoom mediator;
public User(String name) {
this.name = name;
}
public void send(String message, String to) {
mediator.sendMessage(this, message, to);
}
public void receive(String message) {
System.out.println(this.name + " received: " + message);
}
public void setMediator(ChatRoom mediator) {
this.mediator = mediator;
}
}
// 中介者接口
interface ChatRoom {
void register(User user);
void sendMessage(User from, String message, String to);
}
// 具体中介者
class ChatRoomImpl implements ChatRoom {
private Map<String, User> users = new HashMap<>();
public void register(User user) {
users.put(user.getName(), user);
user.setMediator(this);
}
public void sendMessage(User from, String message, String to) {
User toUser = users.get(to);
if (toUser != null) {
toUser.receive(from.getName() + ": " + message);
}
}
}
// 客户端代码
public class ChatRoomTest {
public static void main(String[] args) {
ChatRoom chatRoom = new ChatRoomImpl();
User user1 = new User("User1");
User user2 = new User("User2");
chatRoom.register(user1);
chatRoom.register(user2);
user1.send("Hello User2", "User2");
user2.send("Hi User1", "User1");
}
}在这个示例中，ChatRoom 类作为中介者，协调 User 对象之间的消息发送。每个 User 对象只知道如何发送消息给中介者，而不知道其他 User 对象的存在。这样，系统的耦合度降低，易于扩展和维护。
豆包
中介者模式是一种行为型设计模式，它通过使用一个中介对象来封装一系列对象之间的交互，使得这些对象之间不需要显式地相互引用，从而降低了对象之间的耦合度。
在中介者模式中，中介者对象负责协调各个同事对象之间的通信。同事对象只与中介者对象进行交互，而同事对象之间不直接进行通信。
以下是一个简单的 Java 中介者模式示例：
interface Mediator {
void notifyColleagues(String message, Colleague colleague);
}
class ConcreteMediator implements Mediator {
private Colleague1 colleague1;
private Colleague2 colleague2;
public void setColleague1(Colleague1 colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(Colleague2 colleague2) {
this.colleague2 = colleague2;
}
@Override
public void notifyColleagues(String message, Colleague colleague) {
if (colleague == colleague1) {
colleague2.receive(message);
} else {
colleague1.receive(message);
}
}
}
abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void receive(String message);
}
class Colleague1 extends Colleague {
public Colleague1(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.notifyColleagues(message, this);
}
@Override
public void receive(String message) {
System.out.println("Colleague1 收到消息: " + message);
}
}
class Colleague2 extends Colleague {
public Colleague2(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.notifyColleagues(message, this);
}
@Override
public void receive(String message) {
System.out.println("Colleague2 收到消息: " + message);
}
}
public class MediatorPatternExample {
public static void main(String[] args) {
Mediator mediator = new ConcreteMediator();
Colleague1 colleague1 = new Colleague1(mediator);
Colleague2 colleague2 = new Colleague2(mediator);
((ConcreteMediator) mediator).setColleague1(colleague1);
((ConcreteMediator) mediator).setColleague2(colleague2);
colleague1.send("Hello from Colleague1");
colleague2.send("Hi from Colleague2");
}
}在上述示例中，Mediator 接口定义了中介者的行为，ConcreteMediator 实现了中介者的具体逻辑。Colleague 是抽象同事类，Colleague1 和 Colleague2 是具体的同事类。通过中介者对象来协调同事对象之间的通信，实现了对象之间的解耦。
扫一扫
1648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
