中介者模式

最新推荐文章于 2024-11-02 15:12:27 发布
最新推荐文章于 2024-11-02 15:12:27 发布
阅读量106 收藏
点赞数
分类专栏： java 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/warren_percy/article/details/107806147
版权

一. 智能家庭项目

  1. 智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘 等
  2. 主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起-> 咖啡机开始做咖啡-> 窗帘自动落下-> 电视机开始播放
    二. 传统方案解决智能家庭管理问题
    在这里插入图片描述

三. 传统的方式的问题分析

  1. 当各电器对象有多种状态改变时，相互之间的调用关系会比较复杂
  2. 各个电器对象彼此联系，你中有我，我中有你，不利于松耦合
  3. 各个电器对象之间所传递的消息(参数)，容易混乱
  4. 当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性、扩展性都不理想 考虑中介者模式

四. 终结者模式基本介绍

  1. 中介者模式(Mediator Pattern)，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互应用，从而使其耦合松散，而且可以独立地改变它们之间地交互
  2. 终结者模式属于行为型模式，使代码易于维护
  3. 比如MVC模式，C (Controller 控制器)是 M (Model 模型) 和 V (View 视图) 的中介者，在前后端交互时起到了中间人的作用

五. 中介者模式的原理类图
在这里插入图片描述

对原理类图的说明-即(中介者模式的角色及职责)

  1. Mediator 就是抽象中介者，定义了同事对象到中介者对象的接口
  2. Colleague 是抽象同事类
  3. ConcreteMediator 具体的中介者对象，实现抽象方法，他需要知道所有的具体的同事类，即以一个集合来管理HashMap，并接受某个同事对象消息，完成相应的任务
  4. ConcreteColleague 具体的同事类，会有很多，每个同事只知道自己的行为，而不了解其他同事类的行为(方法)，但是它们都依赖中介者对象

六. 中介者模式应用实例-智能家庭管理

  1. 应用实例要求
    完成前面的智能家庭的项目，使用中介者模式
  2. 思路分析和图解(类图)
    在这里插入图片描述
  3. 代码实现
package com.percy.mediator;
public abstract class Mediator {
    // 将给中介者对象 加入到集合中
    public abstract void Register(String colleagueName, Colleague colleague);
    // 接收消息 具体的同事对象发出
    public abstract void GetMessage(int stateChange, String colleagueName);
    
    public abstract void sendMessage();
}

package com.percy.mediator;
import java.util.HashMap;
// 具体的中介者类
public class ConcreteMediator extends Mediator{
    // 集合， 放入所有的同事对象
    private HashMap<String, Colleague> colleagueMap;
    private HashMap<String, String> interMap;
    public ConcreteMediator() {
        colleagueMap = new HashMap<String, Colleague>();
        interMap = new HashMap<String, String>();
    }
    @Override
    public void Register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName, colleague);
        if(colleague instanceof Alarm) {
            interMap.put("Alarm", colleagueName);
        }else if(colleague instanceof CoffeeMachine) {
            interMap.put("CoffeeMachine", colleagueName);
        }else if(colleague instanceof TV) {
            interMap.put("TV", colleagueName);
        }else if(colleague instanceof Curtains) {
            interMap.put("Curtains", colleagueName);
        }
    }
    // 具体中介者的核心方法
    // 1. 根据得到消息 完成对应任务
    // 2. 中介者在这个方法，协调各个具体的同事对象，完成任务
    @Override
    public void GetMessage(int stateChange, String colleagueName) {
        // 处理闹钟发出的消息
        if(colleagueMap.get(colleagueName) instanceof Alarm) {
            if(stateChange == 0) {
                ((CoffeeMachine) colleagueMap.get(interMap.get("CoffeeMachine"))).StartCoffee();
                ((TV) colleagueMap.get(interMap.get("TV"))).StartTv();
            }else if(stateChange == 1) {
                ((TV) colleagueMap.get(interMap.get("TV"))).StopTv();
            }
        }else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
            ((Curtains) colleagueMap.get(interMap.get("Curtains"))).UpCurtains();
        }else if(colleagueMap.get(colleagueName) instanceof TV) {
            
        }else if(colleagueMap.get(colleagueName) instanceof Curtains) {
            // 如果是以窗帘发出的消息，这里处理
        }
    }
    @Override
    public void sendMessage() {
        // TODO Auto-generated method stub
        
    }
}

package com.percy.mediator;
public abstract class Colleague {
    private Mediator mediator;
    public String name;
    public Colleague(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }
    public Mediator GetMediator() {
        return this.mediator;
    }
    public abstract void SendMessage(int stateChange);
}

package com.percy.mediator;
public class CoffeeMachine extends Colleague{
    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name, this);
    }
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
    
    public void StartCoffee() {
        System.out.println("It's time to startcoffee!");
    }
    
    public void FinishCoffee() {
        System.out.println("After 5 minutes!");
        System.out.println("Coffee is ok!");
        SendMessage(0);
    }
    
}

package com.percy.mediator;
public class Alarm extends Colleague{
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        // 在创建Alarm 同事对象时，将自己放到ConcretetMediator对象中[集合]
        mediator.Register(name, this);
    }
    
    public void SendAlarm(int stateChange) {
        SendMessage(stateChange);
    }
    @Override
    public void SendMessage(int stateChange) {
        // 调用的中介者对象的getMessage
        this.GetMediator().GetMessage(stateChange, this.name);
    }
}

package com.percy.mediator;
public class Curtains extends Colleague{
    public Curtains(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name, this);
    }
    
    public void UpCurtains() {
        System.out.println("I am holding Up Curtains!");
    }
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, name);
    }
    
}

package com.percy.mediator;
public class TV extends Colleague{
    public TV(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name, this);
    }
    public void StartTv() {
        System.out.println("It's time to StartTv!");
    }
    public void StopTv() {
        System.out.println("StopTv!");
    }
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
}

package com.percy.mediator;
public class ClientTest {
    public static void main(String[] args) {
        // 创建一个中介者对象
        Mediator mediator = new ConcreteMediator();
        // 创建 Alarm 并且加入到 ConcreteMediator 对象的 HashMap
        Alarm alarm = new Alarm(mediator, "alarm");
        // 创建Coffee对象 并且加入到 ConcreteMediator 对象的 HashMap
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");
        // 创建Curtains对象 并且加入到 ConcreteMediator 对象的 HashMap
        Curtains curtains = new Curtains(mediator, "curtains");
        TV tV = new TV(mediator, "TV");
        // 让闹钟发出消息
        alarm.SendAlarm(0);
        coffeeMachine.FinishCoffee();
        alarm.SendAlarm(1);
    }
}

七. 中介者模式的注意事项和细节

  1. 多个类相互耦合会形成网状结构，使用中介者模式将网状结构分离成星形结构，进行解耦
  2. 减少类间依赖 降低了耦合 符合迪米特原则
  3. 中介者承担了较多的责任 一旦中介者出现问题，整个系统将会受到影响
  4. 如果设计不当，中介者对象本身变得过于复杂，这点在实际应用时需要特别注意
warrenpercy
关注
专栏目录
设计模式——终结者模式
无忧少年的博客
01-19 3578
中介者模式 @author lisiwen @createTime 2020/01/08 ​ **中介者模式(Mediator)：**用一个中介者对象来封装一系列的对象交互。中介者使各个对象不需要显示地互相引用，从而使其耦合松散，而且可以独立的改变他们之间的交互。 代码示例 Colleague.java /** * @ProjectName: designpattern * @Clas...
设计模式——终结者模式(Mediator)
晴天的专栏
03-12 1100
定义： 用一个中介对象来封装一系列的对象交互。Mediator使各对象不需要显示的相互引用，从而使其耦合松散，以便可以独立地改变他们之间的交互。 说明： 在软件构建过程中，经常会出现多个对象相互关联交互的情况，对象之间常常会维持一种复杂的引用关系，如果遇到一些需求的更改，这种直接的引用关系将面临不断的变化。在这种情况下，我们可以使用一个“中介对象”来管理对象间的关联关系，避免相互交互
中介者模式（Mediator）
指尖飞舞
02-07 2622
中介者模式（Mediator），用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的相互引用，从而使其耦合松散，而且可以独立的改变它们之间的交互。 中介者模式UML类图：        由上图可以看出：Mediator 抽象中介者类，定义了同事对象到中介者对象的接口；Colleague抽象同事类；ConcreteMediator具体中介者类，实现抽象类的方法，它需要知道所有的具
设计模式（18）——中介者模式
minge0001的博客
05-12 507
目录智能家庭项目传统方案解决智能家庭管理问题中介者模式中介者模式应用实例-智能家庭管理中介者模式的注意事项和细节 智能家庭项目 智能家庭项目 智能家庭包括各种设备、闹钟、咖啡机、电视机、窗帘 等 主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起 -> 咖啡机开始做咖啡 -> 窗帘自动落下 -> 电视机开始播放 传统方案解决智能家庭管理...
if else终结者——策略模式
热门推荐
weixin_44991304的博客
05-28 1万+
你是不是还在写着大量的if else语句，if else 不仅难以维护不易扩展，而且使代码臃肿不堪，想不想让你的业务代码更加的健壮，更易扩展，那你一定要学一学今天的主角策略模式。学会了策略模式的使用让会你的代码更加优雅。老板看了给你加薪。同事看了对你仰慕。策略模式大家用了都说好。 阅读完本篇文章你将了解到什么是策略模式，策略模式的优缺点，以及策略模式在源码中的应用。 策略模式引入 在软件开发中，我们常常会遇到这样的情况，实现某一个功能有多条途径，每一条途径对应一种算法，此时我们可以使用一种设计模式来实现.
局域网终结者_p2p终结者怎么安装使用 p2p终结者安装使用方法【介绍】
weixin_39854681的博客
10-24 1204
　　p2p终结者是一款局域网控制软件，他的主要功能就是控制和限制同一个局域网内其它的上网用户，如限制不让别人上QQ，不让别人开网页和不让别人下载，只要他和你在同一网之内你就可以控制他，并且神奇的是，不需要动他的电脑或在他的电脑上安装什么，而是只需在你的电脑上安装运行p2p终结者就可以达到前面所述的功能。在之前的版本中，P2P终结者是收费的，从3.X的某个版本开始免费提供给家庭用户使用　　点击进入p...
【软考笔记 ——软件设计师】（七） 设计模式 总结
CPT1024
09-26 5409
总结看红色设计模式4个基本要素1、模式名称2、问题3、解决方案4 、 效果背 中英都要适配器模式 类和对象都一样背创建型 和 结构型创建型 （类 / 对象 ） 模式。
解锁《终结者：幸存者》新玩法：Steam家庭共享机制详解与实战指南
czl922的博客
08-12 1214
在Steam平台上，玩家可以通过家庭共享功能，与亲朋好友共享自己购买的游戏库，包括《终结者：幸存者》这款游戏。
植物大战僵尸花瓶终结者（砸罐子）无尽模式47波通关小技巧攻略
Ryo_Yuki
08-16 4151
虽然有点儿影响博客环境，不过这么砸罐子益脑的游戏怎么能没有人玩！ 最近玩的有点上头，最长记录打到了37波
科幻电影系列 - 终结者
数字人生
04-26 1010
本片在剧情方面是《终结者2:审判日》的直接延续，讲述了是以T-800战斗最激烈壮阔、最为夸张的一次，他不仅是队伍的精神领袖，也是几位女性角色的后盾，戴上墨镜象征着他往昔英勇的回归，他们从高速公路打到空中对撞的“银河C5”运输机，再到水坝的涡轮大厅。并成为莎拉和约翰的保护者之一。为了改变未来的历史，挽救人类的命运，萨拉、约翰和T-800 Model 101找到了“天网”之父，迈尔斯·戴森（乔·莫顿 饰），说服他销毁一切有关“天网”的资料，此时，警察和T-1000同时赶来，他们陷入了多方争斗中 [2]。
终结者2.2本地生成版+终结者完整金牌验证-源码
10-31
【终结者2.2本地生成版】是一款针对软件授权验证技术的工具，它允许开发者在本地环境下生成软件的授权信息，以实现对软件使用的有效控制。这个版本的终结者主要聚焦于提供一种安全且便捷的方式来验证软件的合法性，...
Unity设计模式—中介者模式
问渠哪得清如许，为有源头活水来
02-15 508
本文介绍在Unity中实现一个EventManager，用于集中管理所有的事件。包含泛型参数传递。中介者模式：用一个中介对象封装一系列的对象交互，中介者使对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
策略模式、观察者模式、状态模式原理及实例
BaiKnow的博客
02-03 1248
策略模式 基本介绍 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户 这算法体现了几个设计原则。 第一 把变化的代码从不变的代码中分离出来 第二 针对接口编程而不是具体类（定义了策略接口 第三 多用组合/聚合，少用继承（客户通过组合方式使用策略）。 策略模式就是通过组合的方式将类的一些方法组合起来，每个类都可以持有不同的策略。通过持有不同的策略来达到同样方法不同执行方式的效果。 context就是用来存放策
设计模式概述
小林的博客
10-30 383
直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。
Java设计模式之责任链模式
cxbtdd的博客
11-02 175
责任链模式(Iterator Pattern)是一种行为型设计模式，使多个对象都有机会处理同一个请求，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。处理器链HandlerChain：通过数组或链表组织各个具体的处理器形成一个处理器链，提供添加处理器的方法，并调用处理器的处理方法。2.在请求处理器个数未知的情况下，或者请求处理器可动态配置的情况下，可以使用责任链模式。具体处理器Handler：对抽象处理器的具体实现，重写处理方法，调用处理器链的方法。4、使用责任链模式的样例代码一。
【Java】设计模式——单例设计模式
最新发布
啊松同学的博客
11-02 539
单例设计模式介绍
Java设计模式之观察者模式
cxbtdd的博客
11-02 627
观察者模式（Observer），又叫发布-订阅模式（Publish/Subscribe），是一种行为型模式，定义对象间一对多的依赖关系（注册），使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新（通知）。Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。2.当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
微服务设计模式 - 发布订阅模式（Publisher Subscriber Pattern）
2404_88048702的博客
11-02 726
发布-订阅模式是实现松耦合系统的强大工具，在云计算和分布式系统中应用广泛。通过使用如RabbitMQ的消息中间件，我们可以很容易地在Spring Boot项目中实现这一模式。通过本文的示例，我们展示了如何利用配置消费者行为，并通过Spring Boot注解进行订阅，从而实现发布-订阅模式的精细化控制和一个完整的发布-订阅模式。这种模式不仅提高了系统的扩展性和灵活性，还大大简化了开发过程中的依赖管理。
设计模式——外观模式
chuliling0446的博客
10-30 1022
这些是实现具体功能的类，它们组成了一个子系统。子系统类之间可能存在复杂的交互和依赖关系，这些关系对于客户端来说可能是难以理解和操作的。外观类是外观模式的核心，它知道哪些子系统类负责哪些功能，并将客户端的请求转发给相应的子系统类来处理。外观类提供了一个简化的接口，隐藏了子系统类的复杂性。
多功能批量更名工具：批量更名终结者2022
资源摘要信息:"批量更名终结者2022是一款专业的批量文件和文件夹重命名工具，具有多种实用功能，能够满足用户在文件管理中的各种重命名需求。它集成了简化的资源管理器界面，提供了全盘搜索功能，以及高级的多模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值