笨蛋学设计模式行为型模式-中介者模式【24】

行为型模式-中介者模式

• • 8.11中介者模式
  • • 8.11.1概念
    • 8.11.2场景
    • 8.11.3优势 / 劣势
    • 8.11.4模式可分为
    • 8.11.5模式
    • 8.11.6实战
    • • 8.11.6.1题目描述
      • 8.11.6.2输入描述
      • 8.11.6.3输出描述
      • 8.11.6.4代码
      • 8.11.7总结

        8.11中介者模式

        8.11.1概念

        ​ 中介者模式通过引入一个中介者对象来封装一组对象之间的交互，从而可以使这些对象不需要直接相互引用，也就是将系统内多个对象之间的复杂关系转化为多个对象与中介者之间的简单关系。

        8.11.2场景

        ​ 在生活中，可以看到不少网红在直播卖货，也可以看出中介者模式。在主播卖货的过程中，由于设计到多个对象，比如商品、观众、平台等，每个对象都有自己的任务和职责，但是它们之间需要相互协调和交互才能顺利完成卖货的过程。其中主播可以充当中介者的角色，负责协调和调度各个对象的交互。

        8.11.3优势 / 劣势

        • 增加可扩展性：当需要增加新的交互时，只需添加新的中介类，而不需要修改已有的类
        • 提高可维护性：可以将多个对象之间的交互逻辑集中在一个对象中

          ---

          • 额外的复杂性：引入中介者模式会增加系统的复杂性，因为需要定义中介者接口和实现类，以及将原有对象与中介者对象进行交互
          • 中介者对象职责过重：中介者对象需要处理所有对象之间的交互，与整个系统进行挂钩，一旦出现问题，整个系统也会出现问题

            8.11.4模式可分为

            • 抽象中介者Mediator：定义中介者的接口，用于各个具体同事对象之间的通信
            • 具体中介者ConcreteMediator：实现抽象中介者接口，负责协调各个具体同事对象的交互关系，它需要知道所有具体同事类，并从具体同事接收消息，向具体同事对象发出命令
            • 抽象同事类Colleague：定义同事类的接口，维护一个对中介者对象的引用，用于通信
            • 具体同事类ConcreteColleague：实现抽象同事类接口，每个具体同事类只知道自己的行为，而不了解其他同事类的情况，因为它们都需要与中介者通信，通过中介者协调与其他同事对象的交互

              8.11.5模式

              package com.technologystatck.designpattern.mode.tertiumquid;
              import java.util.ArrayList;
              import java.util.List;
              public class TertiumQuid {
                  public static void main(String[] args) {
                      //创建中介者
                      ConcreteMediator mediator = new ConcreteMediator();
                      //创建同事对象
                      Colleague colleague1 = new ConcreteColleague1(mediator);
                      Colleague colleague2 = new ConcreteColleague2(mediator);
                      //注册同事对象到中介者
                      mediator.register(colleague1);
                      mediator.register(colleague2);
                      //同事对象发送消息
                      colleague1.send("Hello, colleague2!");
                      colleague2.send("Hello, colleague1!");
                  }
              }
              //抽象中介者
              abstract class Mediator {
                  void register(Colleague colleague){};
                  //定义一个抽象的发送消息方法
                  public abstract void send(String message, Colleague colleague);
              }
              //具体中介者
              class ConcreteMediator extends Mediator{
                  private List colleagues = new ArrayList<>();
                  @Override
                  public void register(Colleague colleague) {
                      colleagues.add(colleague);
                  }
                  @Override
                  public void send(String message,Colleague colleague) {
                      for (Colleague c : colleagues) {
                          //排除发送消息的同事对象
                          if(c!=colleague){
                              c.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 ConcreteColleague1 extends Colleague{
                  public ConcreteColleague1(Mediator mediator) {
                      super(mediator);
                  }
                  @Override
                  public void send(String message) {
                      mediator.send(message,this);
                  }
                  @Override
                  public void receive(String message) {
                      System.out.println("ConcreteColleague1 received: "+message);
                  }
              }
              //具体同事对象2
              class ConcreteColleague2 extends Colleague{
                  public ConcreteColleague2(Mediator mediator) {
                      super(mediator);
                  }
                  @Override
                  public void send(String message) {
                      mediator.send(message,this);
                  }
                  @Override
                  public void receive(String message) {
                      System.out.println("ConcreteColleague1 received: "+message);
                  }
              }
              

              8.11.6实战

              8.11.6.1题目描述

              小明正在设计一个简单的多人聊天室系统，有多个用户和一个聊天室中介者，用户通过中介者进行聊天，请你帮他完成这个系统的设计。

              8.11.6.2输入描述

              第一行包括一个整数N,表示用户的数量（1 <= N <= 100) 第二行是N个用户，比如User1 User2 User3，用空格分隔 第三行开始，每行包含两个字符串，表示消息的发出者和消息内容，用空格分隔

              8.11.6.3输出描述

              对于每个用户，输出一行，包含该用户收到的所有消息内容。

              8.11.6.4代码

              package com.technologystatck.designpattern.mode.tertiumquid;
              import java.util.*;
              public class Test {
                  public static void main(String[] args) {
                      Scanner scanner = new Scanner(System.in);
                      int nums=scanner.nextInt();
                      //获取用户名列表，用于创建用户对象。
                      ArrayList userNames = new ArrayList<>();
                      for(int i=0;i
                          userNames.add(scanner.next());
                      }
                      ChatRoomMediator mediator = new ChatRoomMediatorImpl();
                      //批量创建用户
                      for (String userName : userNames) {
                          new ConcreteChatUser(userName,mediator);
                      }
                      //发送消息并输出
                      while(scanner.hasNext()){
                          String sender = scanner.next();
                          String message = scanner.next();
                          //获取发送者信息
                          //获取信息具体内容
                          ChatUser user = mediator.getUsers().get(sender);
                          //若用户不为空，则输出信息，否则输出用户不存在。
                          if(user!=null){
                              user.sendMessage(message);
                          }
                      }
                  }
              }
              //抽象中介者
              interface ChatRoomMediator {
                  //发送消息方法
                  void sendMessage(String sender,String message);
                  //添加用户方法
                  void addUser(ChatUser user);
                  //获取用户列表方法，用于输出消息时输出用户列表信息
                  Map getUsers();
              }
              //具体中介者
              class ChatRoomMediatorImpl implements ChatRoomMediator{
                  //用户列表，用于存储所有用户对象，以便后续发送消息时，
                  //遍历所有用户对象，并发送消息给所有用户对象。
                  private Map users=new LinkedHashMap<>();
                  @Override
                  public void sendMessage(String sender, String message) {
                      //遍历所有用户对象，并发送消息给所有用户对象。
                      for(ChatUser user:users.values()){
                          if(!user.getName().equals(sender)){
                              user.receiveMessage(sender,message);
                          }
                      }
                  }
                  @Override
                  public void addUser(ChatUser user) {
                      users.put(user.getName(),user);
                  }
                  @Override
                  public Map getUsers() {
                      return users;
                  }
              }
              //抽象同事类
              abstract class ChatUser{
                  private String name;
                  private ChatRoomMediator mediator;
                  private List receivedMessages=new ArrayList<>();
                  public ChatUser(String name, ChatRoomMediator mediator) {
                      this.name = name;
                      this.mediator = mediator;
                      mediator.addUser(this);
                  }
                  public String getName() {
                      return name;
                  }
                  //发送消息的方法，由子类实现，实现不同的发送方式
                  public void sendMessage(String message){
                      mediator.sendMessage(name,message);
                  }
                  //接受到消息的方法，由子类实现，实现不同的接受方式
                  public abstract void receiveMessage(String sender,String message);
                  //获取接受者的消息
                  public List getReceivedMessages() {
                      return receivedMessages;
                  }
                  //添加接受者的消息
                  protected void addReceivedMessage(String message){
                      receivedMessages.add(message);
                  }
              }
              //具体同事类
              class ConcreteChatUser extends ChatUser{
                  public ConcreteChatUser(String name, ChatRoomMediator mediator) {
                      super(name, mediator);
                  }
                  //接受到消息的方法，实现不同的接受方式
                  @Override
                  public void receiveMessage(String sender, String message) {
                      String receivedMessage=getName()+" received: "+message;
                      addReceivedMessage(receivedMessage);
                      System.out.println(receivedMessage);
                  }
              }
              

              8.11.7总结

              • 优点：将多个对象的复杂关系转化为多个对象与中介者的简单关系
              • 总结：通过引入抽象中介者用于定义中介者的接口完成各个同事对象之间的通信，具体中介者用于实现抽象中介者以及协调具体同事类之间的关系，抽象同事类用于维护一个对中介者对象的引用，具体同事类用于与中介者与其他同事对象通信，可以不用知道其他同事类，来完成多个对象与中介者对象的关系之间的交互
              • 场景：适用于当系统对象之间存在复杂的交互关系或系统需要在不同的对象之间进行灵活的通信时使用