【设计模式深度剖析】【6】【行为型】【中介者模式】

文章目录

中介者模式
定义
中介者模式的角色
- [1. 中介者（Mediator）](#1. 中介者（Mediator）)
- [2. 具体中介者（ConcreteMediator）](#2. 具体中介者（ConcreteMediator）)
- [3. 同事（Colleague）](#3. 同事（Colleague）)
- 类图
- 代码示例
中介者模式的应用

中介者模式

中介者模式 （Mediator ）也称调停者模式

复杂的网状结构------>星型结构：通过中介者来调停每个类只与中介者有联系，通过中介者解耦。

中介者模式就像是一位"交通警察"，在繁忙的十字路口指挥车辆和行人有序通过，避免他们之间的直接冲突和混乱。

定义

英文原文

Defines a separate (mediator) object that encapsulates the interaction between a set of objects and the objects delegate their interaction to a mediator object instead of interacting with each other directly.

直译

中介者模式定义了一个单独的（中介）对象，用于封装一组对象之间的交互。这组对象将它们的交互委托给中介对象，而不是直接相互交互。

如何理解？

松散耦合：中介者模式通过中介者对象封装了对象之间的交互，使得对象之间不需要直接引用，实现了松散耦合。
独立变化：由于交互逻辑被封装在中介者对象中，因此可以独立地改变对象之间的交互，而不需要修改大量的代码。

假设你正在组织一个家庭聚会，有很多亲戚朋友参与。如果你让每个参与者都直接与每个人交流（例如，每个人都要告诉其他人他们的饮食偏好），那么场面可能会非常混乱，而且很难确保每个人都得到了正确的信息。这时，你可以充当一个"中介者"的角色，让每个人只与你交流他们的需求，然后你再将这些需求传达给其他人。这样，整个聚会过程就会变得更加有序和高效。这就是中介者模式在现实生活中的一个简单应用。

中介者模式的角色

1. 中介者（Mediator）

定义了一个接口，用于封装多个同事（Colleague）对象之间的交互行为，协调它们之间的通信。

维护同事对象之间的关联关系。
协调多个同事对象之间的交互。
封装了同事对象之间的通信细节。

2. 具体中介者（ConcreteMediator）

实现了中介者接口，定义了具体的协调同事对象交互的逻辑。

了解并维护它的各个同事：提供注册同事对象的方法，持有同事对象的引用列表。
实现协调同事对象交互的逻辑。

3. 同事（Colleague）

持有中介者的引用，通过中介者与其他同事对象通信。

每一个同事类都知道它的中介者对象：持有中介者的引用。
提供注册到中介者的方法。
接收来自中介者的消息。
每一个同事对象在需要与其他同事通信的时候，与它的中介者通信：发送消息给中介者，再由中介者转发给其他同事。

类图

代码示例

java 复制代码

package com.polaris.designpattern.list3.behavioral.pattern06.mediator.classicdemo;

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

//中介者接口
interface Mediator {
    void register(Colleague colleague);

    void relay(Colleague source, String message);
}

//具体中介者实现
class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues = new ArrayList<>();

    @Override
    public void register(Colleague colleague) {
        colleagues.add(colleague);
    }

    @Override
    public void relay(Colleague source, String message) {
        for (Colleague otherColleague : colleagues) {
            if (!otherColleague.equals(source)) {
                otherColleague.receive(message);
            }
        }
    }
}


//同事接口
interface Colleague {
    void registerWith(Mediator mediator);

    void receive(String message);

    void send(String message);
}

//具体同事实现
class ColleagueA implements Colleague {
    private Mediator mediator;

    public ColleagueA(Mediator mediator) {
        this.mediator = mediator;
        this.mediator.register(this); // 注册到中介者  
    }

    @Override
    public void registerWith(Mediator mediator) {
        // 已在构造函数中注册，这里无需实现  
    }

    @Override
    public void receive(String message) {
        System.out.println("ColleagueA received: " + message);
    }

    @Override
    public void send(String message) {
        mediator.relay(this, message); // 委托给中介者发送消息  
    }
}

// 同事B的实现与A类似
class ColleagueB implements Colleague {
    private Mediator mediator;

    public ColleagueB(Mediator mediator) {
        this.mediator = mediator;
        this.mediator.register(this); // 注册到中介者  
    }

    @Override
    public void registerWith(Mediator mediator) {
        // 已在构造函数中注册，这里无需实现  
    }

    @Override
    public void receive(String message) {
        System.out.println("ColleagueB received: " + message);
    }

    @Override
    public void send(String message) {
        mediator.relay(this, message); // 委托给中介者发送消息  
    }
}


//客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建中介者  
        Mediator mediator = new ConcreteMediator();

        // 创建并注册同事对象  
        Colleague colleagueA = new ColleagueA(mediator);
        Colleague colleagueB = new ColleagueB(mediator); // 假设ColleagueB是另一个同事实现  

        // 同事A发送消息  
        colleagueA.send("Hello, everyone from ColleagueA!");

        // 同事B也可以发送消息（如果需要）  
        colleagueB.send("Hello, everyone from ColleagueB!");
    }
}  

/* Output:
ColleagueB received: Hello, everyone from ColleagueA!
ColleagueA received: Hello, everyone from ColleagueB!
*///~

在这个例子中，ConcreteMediator 是具体的中介者类，它负责维护同事对象的列表，并协调它们之间的通信。ColleagueA 和 ColleagueB 是具体的同事类，它们通过中介者来发送和接收消息。在客户端代码中，我们创建了中介者和两个同事对象，并将它们注册到中介者中。然后，我们让 ColleagueA 发送一条消息，这条消息将通过中介者转发给所有其他同事（在这个例子中是 ColleagueB）。

中介者模式的应用

中介者模式是一种行为型设计模式，它允许多个对象之间通过一个中介者对象进行通信和协作。这种设计模式通常用于处理多个对象之间的复杂交互关系，以简化系统结构并提高可维护性。

在现实生活中，我们可以将机场的塔台视为一个中介者模式的例子。塔台作为中介者，负责协调不同飞机（对象）之间的起飞和降落，飞机之间无需直接相互通信，而是通过塔台进行交流。

优点

降低系统复杂性：通过将对象间的交互逻辑集中到一个中介者对象中，降低了对象间的直接耦合度，从而简化了系统结构。例如，在聊天室场景中，如果有8个人需要相互通信，使用中介者模式后，每个人只需要与中介者（聊天室）进行交互，而不是与其他7个人分别交互，大大降低了交互的复杂性。
提高可扩展性：当系统需要添加新的交互行为时，只需要修改或扩展中介者对象，而无需修改其他对象，从而提高了系统的可扩展性。
促进松散耦合：由于对象之间不再直接相互依赖，而是通过中介者进行交互，因此对象之间的耦合度大大降低，使得系统更加易于理解和维护。

缺点

中介者对象可能变得复杂：随着系统中对象数量的增加，中介者对象可能需要处理更多的交互逻辑，这可能导致中介者对象变得庞大而复杂，难以维护。
过度依赖中介者：由于所有对象都通过中介者进行交互，因此如果中介者出现故障或性能瓶颈，整个系统可能会受到影响。

使用场景

对象间存在复杂的引用关系：当系统中多个对象之间存在复杂的引用关系，导致系统结构混乱、难以理解时，可以使用中介者模式来简化这些关系。
需要集中控制交互行为：当一组对象之间的交互行为需要进行集中控制时，可以使用中介者模式来维护和管理这些交互行为。
多人协作场景：例如多人聊天室、多人游戏等场景，其中每个人都需要与其他人进行交互，使用中介者模式可以简化这些交互过程。