设计模式-行为型模式:中介者模式

简介: 设计模式-行为型模式:中介者模式

1、简介

中介者模式(Mediator Pattern)是一种行为型设计模式,它通过将对象间的交互行为集中到一个中介对象中,来降低对象间的耦合度,使对象间的通信更加简单。在中介者模式中,各个对象不再直接相互引用,而是通过中介者对象来协调它们的行为。

2、组成部分

中介者模式由以下几个部分组成:

  1. 抽象中介者(Mediator):定义了中介者对象的接口,负责定义对象间的通信协议。
  2. 具体中介者(Concrete Mediator):实现了中介者接口,负责协调各个同事对象之间的交互关系。
  3. 抽象同事类(Colleague):定义了同事对象的接口,负责定义对象间的行为。
  4. 具体同事类(Concrete Colleague):实现了同事接口,负责实现具体的行为。

在中介者模式中,各个同事类不再直接相互引用,而是通过中介者对象来进行通信。当一个同事对象需要与另一个同事对象进行通信时,它并不直接与目标对象通信,而是将请求发送给中介者对象,由中介者对象来处理请求,并将请求转发给目标对象。这样,各个同事对象之间的通信变得更加简单,而且不需要了解彼此的实现细节。

3、优缺点

中介者模式的优点包括:

  1. 降低了对象间的耦合度,使得对象间的通信更加简单。由于中介者对象将对象间的通信集中到一起处理,因此各个对象之间不需要直接相互通信,从而降低了它们之间的耦合度。这使得系统更加灵活,可以更方便地修改、扩展和维护。
  2. 可以减少子类的数量,减少了系统的复杂度。在不使用中介者模式的情况下,多个对象之间的交互可能会相互关联,需要通过建立大量的子类来实现各种不同的交互行为。而使用中介者模式后,各个对象之间的交互将被统一管理,不再需要建立大量的子类,从而减少了系统的复杂度。
  3. 可以更好地控制对象间的交互行为,使得系统更加灵活。由于中介者对象可以统一管理对象间的交互行为,因此可以更方便地控制各个对象之间的交互方式和时机,从而使得系统更加灵活。

中介者模式的缺点包括:

  1. 中介者对象可能变得非常复杂,难以维护和扩展。由于中介者对象需要处理各种不同的交互行为,因此可能会变得非常复杂,难以维护和扩展。此时需要设计合理的中介者对象,使其尽可能简单和易于维护。
  2. 中介者对象会成为系统的瓶颈,影响系统的性能。由于中介者对象需要处理各种不同的交互行为,因此可能会成为系统的瓶颈,影响系统的性能。此时需要设计高效的中介者对象,避免其成为系统的瓶颈。
  3. 中介者模式可能会导致系统变得过于复杂,增加开发和维护的难度。在设计中介者模式时,需要权衡好各个对象之间的关系和交互方式,以及中介者对象的设计和实现方式,否则可能会导致系统变得过于复杂,增加开发和维护的难度。
  4. 中介者模式可能会导致系统扩展困难。在系统运行一段时间后,可能需要增加新的对象或修改原有对象的交互行为,此时需要修改中介者对象的实现方式。如果中介者对象的设计不够灵活,可能会导致系统扩展困难,需要对中介者对象进行大量的修改,甚至重新设计。
  5. 中介者模式可能会隐藏系统的交互细节,降低了系统的透明度。由于中介者对象统一管理对象间的交互行为,可能会隐藏各个对象之间的具体交互细节,降低了系统的透明度。此时需要通过合理的接口设计和文档说明来提高系统的透明度,方便系统的使用和维护。

总的来说,中介者模式适用于对象之间的交互比较复杂、耦合度较高的情况,可以有效地降低对象间的耦合度,提高系统的灵活性和可维护性。但是,在设计中介者模式时需要权衡好各个对象之间的关系和交互方式,以及中介者对象的设计和实现方式,避免引入不必要的复杂度和性能瓶颈。

4、使用场景

中介者模式适用于以下情况:

  1. 对象间的交互比较复杂,存在大量的相互关联和相互依赖,导致对象间的耦合度较高。
  2. 每个对象需要了解其他对象的状态信息,以便在某些情况下进行相应的处理,但这种相互依赖关系使得对象之间的通信比较困难。
  3. 对象间的交互方式和时机经常变化,难以通过继承和重写的方式进行管理和维护。
  4. 系统中存在大量的对象,它们之间的交互方式和时机比较复杂,难以通过简单的方法调用和事件通知来管理和维护。

在这些情况下,使用中介者模式可以有效地降低对象间的耦合度,提高系统的灵活性和可维护性。具体的使用场景包括:

  1. 图形界面应用程序中,各个控件之间的交互很复杂,需要通过中介者来统一管理。
  2. 聊天室等网络应用程序中,用户之间的交互非常频繁,需要通过中介者来管理。
  3. 多人协作编辑系统中,多个用户同时编辑同一文档,需要通过中介者来管理。
  4. 调停系统,如劳资调停、纠纷调停等,需要通过中介者来协调不同的利益关系。
  5. 游戏中,多个角色之间的交互非常复杂,需要通过中介者来管理。

总之,中介者模式适用于对象间的交互比较复杂、耦合度较高的情况,可以有效地降低对象间的耦合度,提高系统的灵活性和可维护性。在实际应用中,需要根据具体的业务需求和系统设计来决定是否采用中介者模式。

5、代码实现

下面我们用 Java 代码实现一个简单的中介者模式示例,以便更好地理解该模式的具体实现方式。

假设我们要实现一个简单的图形界面应用程序,其中包含多个控件,例如按钮、文本框、标签等。这些控件之间存在复杂的交互关系,例如点击按钮可以修改文本框中的文本内容,或者根据文本框中的文本内容来更新标签的显示内容等。为了管理这些控件之间的交互关系,我们使用中介者模式来实现。

首先,我们定义一个中介者接口 Mediator,它包含一个 notify 方法,用于通知中介者有控件的状态发生了变化:

1. public interface Mediator {
2. void notify(Component component, String event);
3. }

其中,component 参数表示发生变化的控件对象,event 参数表示变化的类型。

然后,我们定义一个抽象控件类 Component,它包含一个中介者对象,并提供一个 changed 方法,用于通知中介者控件的状态发生了变化:

1. public abstract class Component {
2. protected Mediator mediator;
3. 
4. public void setMediator(Mediator mediator) {
5. this.mediator = mediator;
6.     }
7. 
8. public void changed(String event) {
9.         mediator.notify(this, event);
10.     }
11. }

其中,setMediator 方法用于设置中介者对象,changed 方法用于通知中介者控件的状态发生了变化。

接下来,我们定义具体控件类,例如 Button、TextBox、Label 等,它们继承自抽象控件类 Component,并实现自己的业务逻辑。例如,我们可以定义一个 Button 类,它在被点击时会通知中介者更新文本框中的文本内容:

1. public class Button extends Component {
2. @Override
3. public void changed(String event) {
4.         mediator.notify(this, event);
5.     }
6. 
7. public void click() {
8.         changed("click");
9.     }
10. }

其中,click 方法表示按钮被点击时的行为,它会调用 changed 方法通知中介者按钮的状态发生了变化。

最后,我们定义一个具体中介者类 ConcreteMediator,它实现了中介者接口,负责控制各个控件之间的交互关系。例如,我们可以定义一个 ConcreteMediator 类,它负责监听按钮的点击事件,并根据按钮的状态更新文本框和标签的显示内容:

1. public class ConcreteMediator implements Mediator {
2. private Button button;
3. private TextBox textBox;
4. private Label label;
5. 
6. public void setButton(Button button) {
7. this.button = button;
8.     }
9. 
10. public void setTextBox(TextBox textBox) {
11. this.textBox = textBox;
12.     }
13. 
14. public void setLabel(Label label) {
15. this.label = label;
16.     }
17. 
18. @Override
19. public void notify(Component component, String event) {
20. if (component == button && event.equals("click")) {
21. String text = textBox.getText();
22.             label.setText("Hello " + text + "!");
23.         } else if (component == textBox && event.equals("change")) {
24. String text = textBox.getText();
25.             label.setText("Hello " + text + "!");
26.         }
27.     }
28. }

在 ConcreteMediator 类中,我们通过判断事件类型来实现控件之间的交互逻辑。例如,如果按钮被点击了,我们可以根据文本框中的文本内容更新标签的显示内容

在 ConcreteMediator 类中,我们通过判断事件类型来实现控件之间的交互逻辑。例如,如果按钮被点击了,我们可以根据文本框中的文本内容更新标签的显示内容

1. public class Main {
2. public static void main(String[] args) {
3. ConcreteMediator mediator = new ConcreteMediator();
4. Button button = new Button();
5. TextBox textBox = new TextBox();
6. Label label = new Label();
7. 
8.         mediator.setButton(button);
9.         mediator.setTextBox(textBox);
10.         mediator.setLabel(label);
11. 
12.         button.setMediator(mediator);
13.         textBox.setMediator(mediator);
14.         label.setMediator(mediator);
15. 
16.         button.click();
17.         textBox.setText("World");
18.     }
19. }

运行上述代码,可以看到控制台输出了以下结果:

       Hello !

       Hello World!

这表明按钮被点击时,中介者更新了标签的显示内容;当文本框的内容发生变化时,中介者也更新了标签的显示内容。

总之,中介者模式是一种有效的设计模式,它可以帮助我们更好地管理多个对象之间的交互关系,从而提高代码的可维护性和可扩展性。

相关文章
|
2月前
|
设计模式 监控 算法
Java设计模式梳理:行为型模式(策略,观察者等)
本文详细介绍了Java设计模式中的行为型模式,包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码,深入浅出地讲解了每种模式的应用场景与实现方式。例如,策略模式通过定义一系列算法让客户端在运行时选择所需算法;观察者模式则让多个观察者对象同时监听某一个主题对象,实现松耦合的消息传递机制。此外,还探讨了这些模式与实际开发中的联系,帮助读者更好地理解和应用设计模式,提升代码质量。
Java设计模式梳理:行为型模式(策略,观察者等)
|
3月前
|
设计模式 Java
Java设计模式-中介者模式(20)
Java设计模式-中介者模式(20)
|
4月前
|
设计模式 算法 Java
【十六】设计模式~~~行为型模式~~~策略模式(Java)
文章详细介绍了策略模式(Strategy Pattern),这是一种对象行为型模式,用于定义一系列算法,将每个算法封装起来,并使它们可以相互替换。策略模式让算法独立于使用它的客户而变化,提高了系统的灵活性和可扩展性。通过电影院售票系统中不同类型用户的打折策略案例,展示了策略模式的动机、定义、结构、优点、缺点以及适用场景,并提供了Java代码实现和测试结果。
【十六】设计模式~~~行为型模式~~~策略模式(Java)
|
4月前
|
设计模式 网络协议 Java
【十五】设计模式~~~行为型模式~~~状态模式(Java)
文章详细介绍了状态模式(State Pattern),这是一种对象行为型模式,用于处理对象在其内部状态改变时的行为变化。文中通过案例分析,如银行账户状态管理和屏幕放大镜工具,展示了状态模式的应用场景和设计方法。文章阐述了状态模式的动机、定义、结构、优点、缺点以及适用情况,并提供了Java代码实现和测试结果。状态模式通过将对象的状态和行为封装在独立的状态类中,提高了系统的可扩展性和可维护性。
【十五】设计模式~~~行为型模式~~~状态模式(Java)
|
4月前
|
设计模式 存储 前端开发
【十四】设计模式~~~行为型模式~~~观察者模式(Java)
文章详细介绍了观察者模式(Observer Pattern),这是一种对象行为型模式,用于建立对象之间的一对多依赖关系。当一个对象状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。文中通过交通信号灯与汽车的案例以及多人联机对战游戏的设计方案,阐述了观察者模式的动机和应用场景。接着,文章介绍了观察者模式的结构、角色、优点、缺点以及适用情况,并通过代码示例展示了如何在Java中实现观察者模式。此外,还探讨了观察者模式在MVC架构中的应用以及Java中对观察者模式的支持。
【十四】设计模式~~~行为型模式~~~观察者模式(Java)
|
4月前
|
设计模式 前端开发 Java
【十三】设计模式~~~行为型模式~~~中介者模式(Java)
文章详细介绍了中介者模式(Mediator Pattern),这是一种对象行为型模式,用于封装一系列对象的交互,降低系统耦合度,并简化对象之间的交互关系。通过案例分析、结构图、时序图和代码示例,文章展示了中介者模式的组成部分、实现方式和应用场景,并讨论了其优点、缺点和适用情况。
【十三】设计模式~~~行为型模式~~~中介者模式(Java)
|
4月前
|
设计模式 安全 Go
[设计模式]行为型模式-观察者模式
[设计模式]行为型模式-观察者模式
|
4月前
|
设计模式 存储 Java
【十二】设计模式~~~行为型模式~~~命令模式(Java)
文章详细介绍了命令模式(Command Pattern),这是一种对象行为型模式,用于将请求封装成对象,实现请求发送者与接收者的解耦,从而降低系统耦合度、提高灵活性,并支持命令的排队、记录、撤销和恢复操作。通过案例分析、结构图、时序图和代码示例,文章展示了命令模式的组成部分、实现方式和应用场景,并讨论了其优点、缺点和适用情况。
|
4月前
|
设计模式 算法 测试技术
[设计模式]行为型模式-策略模式
[设计模式]行为型模式-策略模式
|
5月前
|
设计模式 JavaScript
js设计模式【详解】—— 中介者模式
js设计模式【详解】—— 中介者模式
69 5