中介者模式详解：概念、优点及实例

于 2024-07-20 17:58:08 发布
阅读量513 收藏 4
点赞数 13
分类专栏： Java 设计模式 文章标签： 中介者模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82095378/article/details/140575112
版权

目录

中介者模式

中介者模式是一种行为设计模式， 能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作。

中介者模式结构

在这里插入图片描述

  1. 组件 （Component） 是各种包含业务逻辑的类。 每个组件都有一个指向中介者的引用， 该引用被声明为中介者接口类型。 组件不知道中介者实际所属的类， 因此你可通过将其连接到不同的中介者以使其能在其他程序中复用。

  2. 中介者 （Mediator） 接口声明了与组件交流的方法， 但通常仅包括一个通知方法。 组件可将任意上下文 （包括自己的对象） 作为该方法的参数， 只有这样接收组件和发送者类之间才不会耦合。

  3. 具体中介者 （Concrete Mediator） 封装了多种组件间的关系。 具体中介者通常会保存所有组件的引用并对其进行管理， 甚至有时会对其生命周期进行管理。

  4. 组件并不知道其他组件的情况。 如果组件内发生了重要事件， 它只能通知中介者。 中介者收到通知后能轻易地确定发送者， 这或许已足以判断接下来需要触发的组件了。

    对于组件来说， 中介者看上去完全就是一个黑箱。 发送者不知道最终会由谁来处理自己的请求， 接收者也不知道最初是谁发出了请求。

中介者模式通用代码：

//抽象中介者
abstract class Mediator{
    //定义同事类
    protected List<Colleague> colleagues = new ArrayList<>();
    
    public void addColleague(Colleague colleague){
    colleagues.add(colleague);    
    }
    
    public abstract void sendMessage(String message,Colleague sender);
}

//具体中介类，一般只有一个。
class ConcreteMediator extends Mediator{
    @Override
    public void sendMessage(String message, Colleague sender) {
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {
                colleague.receiveMessage(message);
            }
        }
    }
}

//抽象同事类
abstract class Colleague{
    protected Mediator mediator;
    public Colleague(Mediator mediator){
    this.mediator = mediator;
    mediator.addColleague(this);
}
    public abstract void sendMessage(String name);
    public abstract void receiveMessage(String message);
}

// 具体同事类1
class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("Colleague1 sends: " + message);
        mediator.sendMessage(message, this);
    }

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

// 具体同事类2
class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("Colleague2 sends: " + message);
        mediator.sendMessage(message, this);
    }

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

中介者模式适用场景

  1. 当一些对象和其他对象紧密耦合以致难以对其进行修改时， 可使用中介者模式。

    该模式让你将对象间的所有关系抽取成为一个单独的类， 以使对于特定组件的修改工作独立于其他组件。

  2. 当组件因过于依赖其他组件而无法在不同应用中复用时， 可使用中介者模式。

    应用中介者模式后， 每个组件不再知晓其他组件的情况。 尽管这些组件无法直接交流， 但它们仍可通过中介者对象进行间接交流。 如果你希望在不同应用中复用一个组件， 则需要为其提供一个新的中介者类。

  3. 如果为了能在不同情景下复用一些基本行为， 导致你需要被迫创建大量组件子类时， 可使用中介者模式。

    由于所有组件间关系都被包含在中介者中， 因此你无需修改组件就能方便地新建中介者类以定义新的组件合作方式。
    在这里插入图片描述

中介者模式优缺点

中介者模式优点：

  • 单一职责原则。 你可以将多个组件间的交流抽取到同一位置， 使其更易于理解和维护。

  • 开闭原则。 你无需修改实际组件就能增加新的中介者。

  • 你可以减轻应用中多个组件间的耦合情况。

  • 你可以更方便地复用各个组件。

中介者模式缺点：

  • 中介者会膨胀得很大，逻辑复杂。一段时间后，可能会演化为上帝对象。

练手题目

题目描述

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

输入描述

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

输出描述

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

在这里插入图片描述

题解

初始解法：

import java.util.*;

// 抽象中介者类
abstract class Mediator {
    protected List<Colleague> colleagues = new ArrayList<>();
    
    // 添加同事到列表
    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }
    
    // 抽象方法：发送消息
    public abstract void sendMessage(String name, String message, Colleague sender);
}

// 具体中介者类
class ConcreteMediator extends Mediator {
    // 实现发送消息方法
    @Override
    public void sendMessage(String name, String message, Colleague sender) {
        // 遍历所有同事，将消息发送给除了发送者之外的所有人
        for (Colleague c : colleagues) {
            if (c != sender) {
                c.receiveMessage(name, message);
            }
        }
    }
}

// 抽象同事类
abstract class Colleague {
    protected Mediator mediator;
    protected String name;

    // 构造函数
    public Colleague(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
        mediator.addColleague(this);
    }

    // 抽象方法：发送消息
    public abstract void sendMessage(String message);
    // 抽象方法：接收消息
    public abstract void receiveMessage(String senderName, String message);
}

// 具体同事类
class ConcreteColleague extends Colleague {
    public ConcreteColleague(String name, Mediator mediator) {
        super(name, mediator);
    }
    
    // 实现发送消息方法
    @Override
    public void sendMessage(String message) {
        mediator.sendMessage(this.name, message, this);
    }
    
    // 实现接收消息方法
    @Override
    public void receiveMessage(String senderName, String message) {
        System.out.println(this.name + " received: " + message);
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
    
        // 读取用户数量
        int n = scanner.nextInt();
        scanner.nextLine(); 
        // 读取用户名
        String[] users = scanner.nextLine().split(" ");
        
        // 创建中介者
        Mediator mediator = new ConcreteMediator();
        // 创建用于存储同事对象的映射
        Map<String, Colleague> colleagues = new HashMap<>();
        
        // 创建所有用户的同事对象
        for (String user : users) {
            colleagues.put(user, new ConcreteColleague(user, mediator));
        }
        
        // 读取并处理消息
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ", 2);
            if (parts.length < 2) break;
            
            String senderName = parts[0];
            String message = parts[1];
            
            // 获取发送者并发送消息
            Colleague sender = colleagues.get(senderName);
            if (sender != null) {
                sender.sendMessage(message);
            }
        }
        
        scanner.close();
    }
}

优化后：

import java.util.*;

// 中介者接口
interface Mediator {
    void sendMessage(String message, String sender);
    void addUser(User user);
}

// 具体中介者
class ChatMediator implements Mediator {
    private List<User> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, String sender) {
        for (User user : users) {
            if (!user.getName().equals(sender)) {
                user.receive(message);  
            }
        }
    }

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

// 用户接口
interface User {
    void send(String message);
    void receive(String message);
    String getName();
}

// 具体用户
class ChatUser implements User {
    private String name;
    private Mediator mediator;

    public ChatUser(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
        mediator.addUser(this);
    }

    @Override
    public void send(String message) {
        mediator.sendMessage(message, this.name);
    }

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

    @Override
    public String getName() {
        return this.name;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Mediator mediator = new ChatMediator();
        Map<String, User> users = new HashMap<>();

        int n = scanner.nextInt();
        scanner.nextLine(); 
        String[] userNames = scanner.nextLine().split(" ");

        for (String name : userNames) {
            users.put(name, new ChatUser(name, mediator));
        }

        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ", 2);
            if (parts.length < 2) break;

            String sender = parts[0];
            String message = parts[1];
            User user = users.get(sender);
            if (user != null) {
                user.send(message);
            }
        }

        scanner.close();
    }
}
天马行空的程序猿
关注
  • 13
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java设计模式大全：23种常见的设计模式详解（一）
凛鼕将至的博客
02-05 2078
设计模式是一种解决问题的可复用的设计思路，它提供了一套经验丰富且经过验证的解决方案。设计模式可以帮助开发人员在软件开发过程中更加灵活、高效地解决常见问题，并提高代码的可维护性和可扩展性。设计模式提供了一种标准化和结构化的方法来解决一些常见的设计问题，使得代码更易于理解和维护。文章至此，已接近尾声！希望此文能够对大家有所启发和帮助。在未来的技术学习和工作中，期待与各位大佬共同进步，共同探索新的技术前沿。您的支持是作者创作的最大动力，如果您觉得这篇文章对您有所帮助，请考虑给予一点打赏。
Android编程设计模式之中介者模式详解
08-28
Android 编程设计模式之中介者模式详解 中介者模式（Mediator Pattern）是一种非常重要的设计模式，它主要用于解决多个对象之间的交互问题。在 Android 编程中，中介者模式广泛应用于解决复杂的对象交互问题。 ...
JAVA设计模式之中介者模式详解
励志成为一名优秀的全能型软件开发工程师。
02-14 1864
提到中介模式，有一个比较经典的例子就是航空管制。为了让飞机在飞行的时候互不干扰，每架飞机都需要知道其他飞机每时每刻的位置，这就需要时刻跟其他飞机通信。飞机通信形成的通信网络就会无比复杂。这个时候，我们通过引 入“塔台”这样一个中介，让每架飞机只跟塔台来通信，发送自己的位置给塔台，由塔台来 负责每架飞机的航线调度。这样就大大简化了通信网络。
瑞_23种设计模式_中介者模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
03-29 1768
本文章为瑞_系列专栏之《23种设计模式》的中介者模式篇。中介者模式在框架设计中经常使用，即使框架内部再复杂，其使用方法也会相对简单。如Spring框架中的 BeanFactory 就是中介者模式的一个实现，它作为中介者，负责管理和创建应用程序中的所有 beans ，而不是让 beans 直接相互引用或创建。
23 种设计模式详解（全23种）
热门推荐
人生智慧的博客
06-09 47万+
设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 A、创建...
设计模式详解：汇总
qq_36807862的博客
08-07 1562
二十三个设计模式 模式的四个基本要素： （1）模式名称（Pattern Name） （2）问题 Problem （3）解决方案Solution （4）效果（Consequences） 1.工厂模式 使用场景:在编码的时候不能预见需要创建哪种类的实例； 系统不应该依赖于产品类实例如何被创建、组合和表达的细节； 工厂模式主要是为了创建对象提供了接口，一般来说，分为3类： 1.1 简...
Java进阶 23种设计模式 详解+应用+实例代码
Jiang_bug的博客
06-22 8830
文章目录前言一、单例模式1.概念2.单例模式应用(1) 懒汉式 基础版(2) 懒汉式 双重校验锁版(3) 饿汉式 单例模式(4)登记式 单例模式 前言 Java的 23种设计模式 创建型模式，共五种(1-5)：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种(6-12)：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种(13-23)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式
【设计模式】第十章：组合模式详解及应用案例
Bummon的学习随笔
07-04 348
组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构。
Java常见设计模式总结
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
java设计模式实例详解
蓝天
10-10 398
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下： 二、设计模式的六大原则 1、开闭原则（Open.
深入理解JavaScript系列（36）：设计模式之中介者模式详解
12-11
中介者模式（Mediator），用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 主要内容来自：...
Java设计模式之建造者模式实例详解
08-29
"Java设计模式之建造者模式实例详解" 本文主要介绍了Java设计模式之建造者模式，结合具体实例形式分析了建造者模式的概念、原理、实现方法与相关使用注意事项。 建造者模式的概念 建造者模式（Builder Pattern）...
Python设计模式之建造者模式实例详解
12-25
本文实例讲述了Python设计模式之建造者模式。分享给大家供大家参考，具体如下： 建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 下面是一个建造者模式的...
中介者模式（行为型）
有问题请发邮箱dengyifanlittle@163.com进行讨论
07-15 890
优点与缺点降低耦合性：通过引入中介者对象，同事对象不再需要显式地引用彼此。它们只需要与中介者对象通信，从而降低了对象之间的耦合度，使得代码更易于维护和扩展集中控制：中介者模式将对象之间的交互逻辑集中到一个中介者对象中，简化了对象的管理和协调，便于修改和扩展交互逻辑。提高可读性和可维护性：将复杂的对象交互逻辑从对象本身中提取出来放到中介者中，使得每个对象的职责更加单一，代码更清晰，更易于理解和维护。
【重走编程路】设计模式概述（十二） -- 访问者模式、中介者模式、解释器模式
最新发布
weixin_44595767的博客
07-19 777
访问者模式是一种将数据操作与数据结构分离的设计模式。它定义了一个作用于某对象结构中的各元素的操作，它可以在不修改各元素的类的前提下定义作用于这些元素的新操作。中介者模式定义了一个中介对象来封装一系列对象之间的交互，使得各个对象之间不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。解释器模式定义了一个语言的文法，并构建一个解释器来解释这个语言中的句子。
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 248
改进版与基础版要分开测试，不然会互相影响到。
模板方法原理与C++实现
Black.Spider的博客
07-15 302
定义一个操作中的算法骨架（稳定的），而将一些步骤的实现延迟到子类中（变化的）。模板方法使得子类可以复用一个算法的结构，而只改变（重写）这个算法的特定步骤。模板方法是一种非常实用且常见的设计模式，它使用简单的机制（虚函数）为应用程序框架提供了灵活的扩展点。模板方法中被模板方法调用的虚函数可以有具体实现，也可以没有任何实现（纯虚函数），但一般访问权限为protected，因为作为算法的一部分，它没有对外单独开放的必要。
(三)js前端开发中设计模式之工厂模式
峰会路转的博客
07-17 261
工厂模式是一种创建型设计模式，它可以帮助我们根据需求创建对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天马行空的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值