设计模式详解—中介者模式

一、场景问题

设计一套买房与卖房的交互程序。

二、传统解决方案

最直观的做法是定义卖方和买方的实体，二者直接进行信息交互。但是随着买方和卖方的人数新增，实体之间的交互会变得错综复杂，直接交互的设计方案会导致系统的通信链路交错复杂，且实体之间耦合过多，维护困难。因此我们可以采用中间层（中介）的方式来简化交互流程。即每个客户都只与中介交互，由中介来负责传递消息，使得各个实体间解耦，较少交互上的不便性。（即现在的房地产中介公司，当然缺点就是增加了中介费）。

三、模式剖析

1、模式定义

中介者模式(Mediator Pattern)：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。

2、模式结构

中介者模式一般包含如下角色

• Mediator：抽象中介者角色

  它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。

  abstract class Mediator {
      protected ArrayList<Colleague> colleagues; //用于存储同事对象
  
      //注册方法，用于增加同事对象
      public void register(Colleague colleague) {
          colleagues.add(colleague);
      }
  
      //声明抽象的业务方法
      public abstract void operation();
  }
  

• Concrete Mediator：具体中介者角色

  实现中介者接口，包含各个同时角色的引用，协调各个同事角色之间的交互关系，因此它依赖于同事角色。

  class ConcreteMediator extends Mediator {
      //实现业务方法，封装同事之间的调用
      public void operation() {
          ......
          ((Colleague)(colleagues.get(0))).method1(); //通过中介者调用同事类的方法
          ......
      }
  }
  

• Colleague：抽象同事类角色

  定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能

  abstract class Colleague {
      protected Mediator mediator; //维持一个抽象中介者的引用
  
      public Colleague(Mediator mediator) {
          this.mediator=mediator;
      }
  
      public abstract void method1(); //声明自身方法，处理自己的行为
  
      //定义依赖方法，与中介者进行通信
      public void method2() {
          mediator.operation();
      }
  }
  

• Concrete Colleague：具体同事类角色

  是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互

  class ConcreteColleague extends Colleague {
      public ConcreteColleague(Mediator mediator) {
          super(mediator);
      }
  
      //实现自身方法
      public void method1() {
          ......
      }
  }
  

3、模式结构图

4、使用中介者模式改进案例

4.1、代码展示

• 抽象中介者类：这里是报亭的父类，没有使用抽象类和接口，通知观察者的方法也在此类实现

  public interface Mediator {
  
      /**
       * 客户注册
       * @param member 会员
       * @return void
       **/
      void register(Customer member);
  
      /**
       * 转发客户发的消息到其余客户
       * @param from 发信息的客户
       * @param msg  具体消息
       * @return void
       **/
      void relay(String from, String msg);
  }
  

• 房产中介者类

  public class EstateMediator implements Mediator {
  
      /**
       * 注册在该房产公司的客户（包括卖方和买方）
       */
      private List<Customer> members = new ArrayList<>();
  
      @Override
      public void register(Customer member) {
          members.add(member);
          member.setMediator(this);
      }
  
      @Override
      public void relay(String from, String msg) {
          //通知到其余客户
          for (Customer member : members) {
              if (!member.getName().equals(from)) {
                  System.out.println("中介小哥传递" + from + "发送的消息[" + msg + "]给" + member.getName());
              }
          }
      }
  }
  

• 抽象客户类

  public abstract class Customer {
  
      /**
       * 中介者
       */
      protected Mediator mediator;
      /**
       * 客户姓名
       */
      private String name;
  
  
      public String getName() {
          return name;
      }
  
      public Customer(String name) {
          this.name = name;
      }
  
      public void setMediator(Mediator mediator) {
          this.mediator = mediator;
      }
  
      /**
       * 发送消息
       * @param msg 消息内容
       * @return void
       **/
      public abstract void send(String msg);
  }
  

• 具体客户类

  • 卖方

    public class Seller extends Customer {
    
        public Seller(String name) {
            super(name);
        }
    
        @Override
        public void send(String msg) {
    
            mediator.relay(getName(), msg);
        }
    }
    

  • 买方

    public class Buyer extends Customer {
    
        public Buyer(String name) {
            super(name);
        }
    
        @Override
        public void send(String msg) {
            mediator.relay(getName(), msg);
        }
    }
    

4.2、客户端测试

public static void main(String[] args) throws IOException {
    //定义中介者
    Mediator mediator = new EstateMediator();

    //定义卖方和买方客户
    Customer buyer = new Buyer("张三");
    Customer seller = new Seller("李四");

    //买方和卖方注册到中介公司中
    mediator.register(buyer);
    mediator.register(seller);

    //卖方买方对话，中介者负责传递消息
    seller.send("临近地铁的大三居开始出售了！");
    buyer.send("多大面积啊？");
    seller.send("三室一厅120多平。");
    buyer.send("多少钱啊？");
    seller.send("200万整。");
}

输出

中介小哥传递李四发送的消息[临近地铁的大三居开始出售了！]给张三
中介小哥传递张三发送的消息[多大面积啊？]给李四
中介小哥传递李四发送的消息[三室一厅120多平。]给张三
中介小哥传递张三发送的消息[多少钱啊？]给李四
中介小哥传递李四发送的消息[200万整。]给张三

5、优缺点

• 优点
  • 中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构。
  • 中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”。
  • 可以减少子类生成，中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使各个同事类可被重用，无须对同事类进行扩展。
• 缺点
  • 在具体中介者类中包含了大量同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护

6、使用场景

• 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解。
• 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果需要改变行为则可以增加新的具体中介者类

本文地址：https://blog.csdn.net/weixin_41951205/article/details/109584801