Java设计模式之行为型-中介者模式（UML类图+案例分析）

目录

一、基础概念

二、UML类图

三、角色设计

四、案例分析

五、总结

---

一、基础概念

中介者模式的核心思想是引入一个中介者对象，来封装和管理对象之间的交互关系。

对象之间不再直接交互，而是通过中介者间接交互。这样可以减少对象之间的依赖，实现解耦。中介者就像是对象之间的调停者，协助对象間的交流与相互操作。

总体上，中介者模式可以使原本相互耦合的对象变成松散耦合，提高了灵活性和可维护性。中介者对象承担了对象間交互的责任，每个对象只需关注自身的行为和逻辑，不再与其他对象直接交互。 

二、UML类图

三、角色设计

角色	描述
抽象中介者	定义接口用于与各同事对象通信
抽象同事	相关对象之间通信的对象，它们之间的通信必须通过中介者对象进行
具体中介者	实现中介者的接口，它需要知道所有同事类，并接受同事对象的通知，然后调用同事对象的方法
具体同事类	实现同事的接口，每一个同事类只知道自己的行为，而不了解其他同事类的情况，但是它们可以通过中介者联系其他对象

四、案例分析

下面通过代码实现了一个使用中介者模式的聊天程序的示例：

定义抽象聊天中介者角色：

public interface ChatMediator {

  public void sendMessage(String msg, User user);
  
  public void registerUser(User user);

}

 实现具体的聊天中介者：

import java.util.ArrayList;
import java.util.List;

public class ChatMediatorImpl implements ChatMediator {

  private List users = new ArrayList<>();

  @Override
  public void sendMessage(String msg, User user) {
    for(User u : this.users) {
      if(u != user) {
        u.receiveMessage(msg); 
      }
    }
  }

  @Override
  public void registerUser(User user) {
    this.users.add(user);
  }

}

定义抽象用户：

public abstract class User {

  private String name;
  
  private ChatMediator mediator;
  
  public User(String name, ChatMediator mediator) {
    this.name = name;
    this.mediator = mediator;
  }

  public ChatMediator getChatMediator() {
    return mediator;
  }

  public String getName() {
    return name;
  }

  public abstract void sendMessage(String msg);

  public abstract void receiveMessage(String msg);


}

分别实现具体的用户，Mike和Jack： 

public class Mike extends User{

    public Mike(String name, ChatMediator mediator) {
        super(name, mediator);
    }

    @Override
    public void sendMessage(String msg) {
        this.getChatMediator().sendMessage(msg, this);
    }

    @Override
    public void receiveMessage(String msg) {
        System.out.println(this.getName() + "收到信息: " + msg);
    }
}

public class Jack extends User{

    public Jack(String name, ChatMediator mediator) {
        super(name, mediator);
    }

    @Override
    public void sendMessage(String msg) {
        this.getChatMediator().sendMessage(msg, this);
    }

    @Override
    public void receiveMessage(String msg) {
        System.out.println(this.getName() + "收到信息: " + msg);
    }
}

客户端：

public class Client {

    public static void main(String[] args) {
        // 初始化中介者
        ChatMediator mediator = new ChatMediatorImpl();

        // 初始化用户
        User user1 = new Mike("Mike", mediator);
        User user2 = new Jack("Jack", mediator);

        // 注册用户
        mediator.registerUser(user1);
        mediator.registerUser(user2);

        // 用户互相通信
        user1.sendMessage("你好，我是Mike!");
        user2.sendMessage("你好，我是Jack!");
    }
}

运行结果如下：

整体实现如下： 

1、ChatMediator接口定义了中介者的角色，包含sendMessage和registerUser两个方法。

2、ChatMediatorImpl实现了ChatMediator接口，作为具体的中介者实现。它维护了一个用户列表users，并在sendMessage方法中遍历该列表，将消息转发给除发送用户外的其他用户。

3、User类定义了用户的抽象类，持有中介者对象的引用。它有两个抽象方法sendMessage和receiveMessage。

4、Jack和Mike类继承自User类，实现了sendMessage和receiveMessage方法，通过中介者的引用调用其方法来发送和接收消息。

5、Client类充当客户端角色，创建中介者和用户对象，建立他们之间的关系，并触发他们之间的交互 - 互相发送消息。

总体上，这段代码通过中介者模式实现了用户对象之间的解耦。用户对象不再直接交互，而是通过中介者转发消息。这使得用户对象可以独立变化，新增用户很方便，只需要注册到中介者即可。也遵循了单一职责原则，用户对象只负责自身消息发送接收，中介者负责协调转发。 

五、总结

优点：

1、降低了对象之间的耦合度。对象之间不再直接交互，它们仅需要保持与中介者的依赖关系即可。

2、提高了系统的灵活性。可以独立地改变对象之间的交互。只需要调整中介者的逻辑，不需要修改对象本身。

3、简化了对象。对象本身只需要关注自身的行为逻辑，不需要处理与其他对象的交互关系。

4、提高了复用性。可以复用中介者类，而不需要了解其内部工作机制。

缺点：

1、中介者会变得过于复杂。中介者需要处理所有对象之间的交互，这使得它经常成为一个庞大的类。

2、依赖中介者。整个系统依赖于中介者，一旦中介者发生问题，会影响到所有交互对象。

应用场景：

1、系统中对象间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。

2、一个对象由于引用其他很多对象，导致难以复用该对象。 -想通过一个中间类消除对象之间的紧耦合关系。

符合的设计原则：

1、单一职责原则（Single Responsibility Principle）

中介者专注于对象之间的交互，对象专注于自身的行为和状态，符合单一职责原则。

2、开闭原则（Open Closed Principle）

可以在不修改对象自身的情况下，通过扩展中介者来改变对象交互，符合开闭原则。

3、依赖倒置原则（Dependency Inversion Principle）

对象依赖于中介者接口，而不是具体的中介者类，符合依赖倒置原则。

4、接口隔离原则（Interface Segregation Principle）

中介者模式通过接口定义对象对外交互，符合接口隔离原则，防止污染不需要的接口。