《设计模式的艺术》笔记 - 中介者模式

这篇具有很好参考价值的文章主要介绍了《设计模式的艺术》笔记 - 中介者模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

介绍

        中介者模式用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式,它是一种对象行为模式。

实现

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>
#include <atomic>
#include <vector>
#include <memory>

class Mediator;
class Colleague {   // 抽象同事类
public:
    Colleague(Mediator *mMediator);
    virtual void method1() = 0; // 处理自己的行为
    virtual void method2() = 0; // 与中介者进行通讯
protected:
    Mediator *m_mediator;
};

class Mediator {    // 抽象中介者;
public:
    void registerColleague(Colleague *colleague);

    virtual void operation(Colleague *colleague) = 0;

protected:
    std::vector<Colleague *> m_colleagues;
};

class ConcreteMediator : public Mediator {  // 具体中介者
public:
    void operation(Colleague *colleague) override;
};

class ConcreteColleagueA : public Colleague {    // 具体同事类A
public:
    ConcreteColleagueA(Mediator *mediator);
    void method1() override;

    void method2() override;
};

class ConcreteColleagueB : public Colleague {    // 具体同事类B
public:
    ConcreteColleagueB(Mediator *mediator);
    void method1() override;

    void method2() override;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"
#include <thread>
#include <unistd.h>
#include <sstream>

Colleague::Colleague(Mediator *mMediator) : m_mediator(mMediator) {

}

void Mediator::registerColleague(Colleague *colleague) {
    if (colleague) {
        m_colleagues.push_back(colleague);
    }
}

void ConcreteMediator::operation(Colleague *colleague) {
    for (auto &c : m_colleagues) {
        if (c != colleague) {
            c->method1();
        }
    }
}

ConcreteColleagueA::ConcreteColleagueA(Mediator *mediator) : Colleague(mediator){

}

void ConcreteColleagueA::method1() {
    std::cout << "ConcreteColleagueA处理自身逻辑" << std::endl;
}

void ConcreteColleagueA::method2() {
    std::cout << "ConcreteColleagueA通知中介者" << std::endl;
    if (m_mediator) {
        m_mediator->operation(this);
    }
}

ConcreteColleagueB::ConcreteColleagueB(Mediator *mediator) : Colleague(mediator){

}

void ConcreteColleagueB::method1() {
    std::cout << "ConcreteColleagueB处理自身逻辑" << std::endl;
}

void ConcreteColleagueB::method2() {
    std::cout << "ConcreteColleagueB通知中介者" << std::endl;
    if (m_mediator) {
        m_mediator->operation(this);
    }
}

main.cpp

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    Mediator *mediator = new ConcreteMediator();
    Colleague *colleagueA = new ConcreteColleagueA(mediator);
    Colleague *colleagueB = new ConcreteColleagueB(mediator);
    mediator->registerColleague(colleagueA);
    mediator->registerColleague(colleagueB);
    colleagueA->method2();
    colleagueB->method2();
    delete colleagueA;
    delete colleagueB;
    delete mediator;
    return 0;
}

总结

优点

        1. 中介者模式简化了对象之间的交互,它用中介者和同事的一对多交互代替了原来同事之间的多对多交互。一对多关系更容易理解、维护和扩展,将原本难以理解的网状结构转换成相对简单的星形结构。

        2. 中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合,可以独立地改变和复用每一个同事和中介者,增加新的中介者和新的同事类都比较方便,更好地符合开闭原则。

        3. 可以减少大量同事子类生成。中介者将原本分布于多个对象间的行为集中在一起,改变这些行为只需要生成新的中介者子类即可,这使得各个同事类可以被重用,无须对同事类进行扩展。

缺点

        1. 在具体中介者类中包含了大量同事之间的交互细节,可能会导致具体中介者类非常复杂,使得系统难以维护。

适用场景

        1. 系统中对象之间存在复杂的引用关系,系统结构混乱且难以理解。

        2. 一个对象由于引用了其他很多对象并且直接和这些对象通信,导致难以复用该对象。

        3. 想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。可以通过引入中介者类来实现,在中介者中定义对象交互的公共行为,如果需要改变行为则可以增加新的具体中介者类。

练习

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>
#include <atomic>
#include <vector>
#include <memory>

class Mediator;
class Pane {   // 抽象同事类
public:
    Pane(const std::string &name, Mediator *mediator);
    virtual void update() = 0; // 处理自己的行为
    virtual void tellOther() = 0; // 与中介者进行通讯
protected:
    Mediator *m_mediator;
    std::string m_name;
};

class Mediator {    // 抽象中介者;
public:
    void registerPane(Pane *pane);

    virtual void operation(Pane *pane) = 0;

protected:
    std::vector<Pane *> m_panes;
};

class Window : public Mediator {  // 具体中介者
public:
    void operation(Pane *pane) override;
};

class TextPane : public Pane {    // 具体同事类TextPane
public:
    TextPane(const std::string &name, Mediator *mediator);
    void update() override;

    void tellOther() override;
};

class ListPane : public Pane {    // 具体同事类ListPane
public:
    ListPane(const std::string &name, Mediator *mediator);
    void update() override;

    void tellOther() override;
};

class GraphicPane : public Pane {    // 具体同事类GraphicPane
public:
    GraphicPane(const std::string &name, Mediator *mediator);
    void update() override;

    void tellOther() override;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"
#include <thread>
#include <unistd.h>
#include <sstream>

Pane::Pane(const std::string &name, Mediator *mediator) : m_name(name), m_mediator(mediator) {

}

void Mediator::registerPane(Pane *pane) {
    if (pane) {
        m_panes.push_back(pane);
    }
}

void Window::operation(Pane *pane) {
    for (auto &c : m_panes) {
        if (c != pane) {
            c->update();
        }
    }
}

TextPane::TextPane(const std::string &name, Mediator *mediator) : Pane(name, mediator){

}

void TextPane::update() {
    std::cout << m_name << "更新显示" << std::endl;
}

void TextPane::tellOther() {
    std::cout << m_name << "通知Window" << std::endl;
    if (m_mediator) {
        m_mediator->operation(this);
    }
}

ListPane::ListPane(const std::string &name, Mediator *mediator) : Pane(name, mediator){

}

void ListPane::update() {
    std::cout << m_name << "更新显示" << std::endl;
}

void ListPane::tellOther() {
    std::cout << m_name << "通知Window" << std::endl;
    if (m_mediator) {
        m_mediator->operation(this);
    }
}

GraphicPane::GraphicPane(const std::string &name, Mediator *mediator) : Pane(name, mediator){

}

void GraphicPane::update() {
    std::cout << m_name << "更新显示" << std::endl;
}

void GraphicPane::tellOther() {
    std::cout << m_name << "通知Window" << std::endl;
    if (m_mediator) {
        m_mediator->operation(this);
    }
}

main.cpp文章来源地址https://www.toymoban.com/news/detail-820000.html

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    Mediator *mediator = new Window();
    Pane *text = new TextPane("text", mediator);
    Pane *list = new ListPane("list", mediator);
    Pane *graphic = new ListPane("graphic", mediator);
    mediator->registerPane(text);
    mediator->registerPane(list);
    mediator->registerPane(graphic);
    std::cout << "-------------------------" << std::endl;
    text->tellOther();
    std::cout << "-------------------------" << std::endl;
    list->tellOther();
    std::cout << "-------------------------" << std::endl;
    graphic->tellOther();
    std::cout << "-------------------------" << std::endl;

    delete text;
    delete list;
    delete graphic;
    delete mediator;
    return 0;
}

到了这里,关于《设计模式的艺术》笔记 - 中介者模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式之中介者模式

    详细介绍         中介者模式(Mediator Pattern)是一种行为设计模式, 它通过定义一个中介类来封装多个对象之间的交互,使各对象不需要显示地相互引用,从而降低耦合度,提高系统的可维护性和灵活性。中介者模式将原本一对多的网状关系转变为一对多的关系,即每个

    2024年04月29日
    浏览(66)
  • 设计模式(十七)中介者

    义一个对象来封装一系列的对象交互。中介者模式使各对象不需要显示地相互引用,从而使其耦合松散,而且可以让你相对独立地改变它们之间的交互。中介者模式又称为调停模式,它是一种对象说行为型模式。 在中介者模式中,引入了用于协调其他对象/类之间的相互调用

    2024年02月04日
    浏览(38)
  • Java设计模式-中介者模式

    中介者模式,就是用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地互相引用,从而使其耦合松散,而且可以独立的改变它们之间的交互。 其实中介者模式很简单的,就像它的名字一样,中介,调用某个类的某些方法的时候,我们不直接去跟那个类的实

    2024年02月15日
    浏览(39)
  • 行为型设计模式——中介者模式

    中介者模式主要是将关联关系由一个中介者类统一管理维护,一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下左图中,有六个同事类对象

    2024年01月18日
    浏览(47)
  • 大话设计模式之中介者模式

    中介者模式是一种行为型设计模式,它通过引入一个中介者对象来封装一系列对象之间的交互,从而减少对象之间的直接通信,使得对象之间的耦合度降低,同时提高了系统的可维护性和灵活性。 在中介者模式中,对象之间的通信不再直接发生,而是通过中介者对象来进行。

    2024年04月16日
    浏览(42)
  • 设计模式- 中介者模式(Mediator)

    中介者模式(Mediator Pattern),是一种对象行为型模式。该模式的主要目的是定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合变得松散,并且可以独立地改变它们之间的交互。 抽象中介者(Mediator) :这是中介者模式的核心接口,它定义了同事对象注

    2024年04月26日
    浏览(36)
  • 经典的设计模式17——中介者模式

    定义: 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互。 结构: 抽象中介者角色:是中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。 具体中介者角色:实现中

    2024年02月09日
    浏览(41)
  • C++ 设计模式之 中介者模式

    【声明】本题目来源于卡码网(题目页面 (kamacoder.com)) 【提示:如果不想看文字介绍,可以直接跳转到C++编码部分】         -- 什么是中介者模式  (第16种模式)          中介者模式 (Mediator Pattern)也被称为 调停者模式 ,是⼀种 ⾏为型设计模式 ,它通过⼀个中介

    2024年01月19日
    浏览(34)
  • 设计模式—行为型模式之中介者模式

    中介者模式(Mediator Pattern):用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,减少对象间混乱的依赖关系,从而使其耦合松散,而且可以独立地改变它们之间的交互。对象行为型模式。 包含以下角色: Mediator: 抽象中介者 ConcreteMediator: 具体中

    2024年01月16日
    浏览(45)
  • 设计模式-行为型模式之中介者模式

    在用户与用户直接聊天的设计方案中,用户对象之间存在很强的 关联性 ,将导致系统出现如下问题: 对象之间存在大量的相互关联和调用,若有一个对象发生变化,则需要跟踪和该对象关联的其他所有对象,并进行适当处理。 由于一个对象和其他对象具有很强的关联,若没

    2023年04月23日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包