首页 > Python资料 博客日记

Java设计模式之中介者模式

2024-08-17 09:00:13Python资料围观44

Python资料网推荐Java设计模式之中介者模式这篇文章给大家,欢迎收藏Python资料网享受知识的乐趣

中介者模式概述

中介者模式(Mediator Pattern)是一种行为型设计模式,用于降低多个对象和类之间的通信复杂性。通过引入一个中介者对象,这些对象无需显式地相互调用,转而通过中介者对象进行交互。这种模式的主要目的是减少对象之间的依赖关系,避免对象间的直接引用,增加系统的灵活性和可扩展性。

中介者模式的结构

中介者模式主要包括以下几个部分:

  1. Mediator(抽象中介者):

    • 定义了同事对象之间通信的接口,通常是一个抽象类或接口。
  2. ConcreteMediator(具体中介者):

    • 实现抽象中介者接口,协调各个同事对象之间的交互行为。持有各个同事对象的引用,处理它们之间的通信和协调。
  3. Colleague(同事类):

    • 是各个参与交互的对象。每个同事对象知道自己的中介者对象,并通过中介者来与其他同事对象通信。
      ┌───────────────────────────────┐
      │          Mediator             │
      │ ───────────────────────────   │
      │ + notify(colleague: Colleague) │
      │ + send(message: String,       │
      │        colleague: Colleague)  │
      └───────────────────────────────┘
                    ▲
                    │
                    │
      ┌───────────────────────────────┐
      │      ConcreteMediator          │
      │ ───────────────────────────    │
      │ - colleague1: Colleague1       │
      │ - colleague2: Colleague2       │
      │ + notify(colleague: Colleague) │
      │ + send(message: String,        │
      │        colleague: Colleague)   │
      └───────────────────────────────┘
          ▲                  ▲
          │                  │
          │                  │
      ┌───────────────────────┐      ┌───────────────────────┐
      │      Colleague1        │      │      Colleague2        │
      │ ─────────────────────  │      │ ─────────────────────  │
      │ - mediator: Mediator   │      │ - mediator: Mediator   │
      │ + send(message: String)│      │ + send(message: String)│
      │ + receive(message:     │      │ + receive(message:     │
      │       String)          │      │       String)          │
      └───────────────────────┘      └───────────────────────┘
      

      中介者模式的实现

      下面是中介者模式的一个简单Java实现示例:

      // 抽象中介者
      interface Mediator {
          void send(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 send(String message, Colleague colleague) {
              if (colleague == colleague1) {
                  colleague2.receive(message);
              } else if (colleague == colleague2) {
                  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);
      }
      
      // 具体同事类1
      class Colleague1 extends Colleague {
          public Colleague1(Mediator mediator) {
              super(mediator);
          }
      
          @Override
          public void send(String message) {
              System.out.println("Colleague1 sends message: " + message);
              mediator.send(message, this);
          }
      
          @Override
          public void receive(String message) {
              System.out.println("Colleague1 received message: " + message);
          }
      }
      
      // 具体同事类2
      class Colleague2 extends Colleague {
          public Colleague2(Mediator mediator) {
              super(mediator);
          }
      
          @Override
          public void send(String message) {
              System.out.println("Colleague2 sends message: " + message);
              mediator.send(message, this);
          }
      
          @Override
          public void receive(String message) {
              System.out.println("Colleague2 received message: " + message);
          }
      }
      
      // 测试类
      public class MediatorPatternDemo {
          public static void main(String[] args) {
              ConcreteMediator mediator = new ConcreteMediator();
      
              Colleague1 colleague1 = new Colleague1(mediator);
              Colleague2 colleague2 = new Colleague2(mediator);
      
              mediator.setColleague1(colleague1);
              mediator.setColleague2(colleague2);
      
              colleague1.send("Hello from Colleague1");
              colleague2.send("Hello from Colleague2");
          }
      }
      

      中介者模式的优缺点

      优点:
    • 降低耦合性: 中介者模式将对象之间的通信封装在中介者中,减少了对象之间的直接依赖关系。
    • 便于扩展: 新增或修改某个对象时,不需要影响其他对象,只需修改中介者的逻辑即可。
    • 提高可维护性: 复杂的交互行为集中在中介者中,逻辑清晰,便于维护和修改。
    • 缺点:
    • 中介者复杂性增加: 随着对象的增多和交互逻辑的复杂化,中介者对象可能会变得庞大且难以管理。
    • 可能导致性能问题: 如果中介者处理了过多的逻辑,可能会引发性能瓶颈。
    • 中介者模式适用于以下场景:

    • 对象之间有复杂的交互关系,且依赖关系呈网状: 使用中介者模式可以简化对象之间的交互,避免直接引用。
    • 一个类多次与其他类交互且无法复用交互逻辑: 将这些交互逻辑集中在中介者中,可以避免重复代码。
    • 系统中的类需要进行多对多的通信,且通信逻辑可能发生变化: 通过引入中介者,可以灵活地调整对象之间的通信方式。
    • 通过使用中介者模式,可以使系统更加模块化和灵活,但也要注意控制中介者的复杂度,以避免反而增加系统的维护难度。

      适用场景


版权声明:本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若内容造成侵权/违法违规/事实不符,请联系邮箱:jacktools123@163.com进行投诉反馈,一经查实,立即删除!

标签:

相关文章

本站推荐