设计模式-第二十一章-中介者模式

一、UML图

二、包含的角色

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

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

ConcreteComponent 类，具体组件类，实现组件基类的接口，不同组件具体功能

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

三、特点

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

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

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

四、代码实现

Mediator接口

#pragma once
class Component;
class Mediator {
 public:
  Mediator(){}
  virtual ~Mediator() {}
 public:
  virtual void Notify(Component *sender) const = 0;
};

Component基类

#pragma once
#include "Mediator.h"
#include <string>
class Component
{

public:
  Component(int key) :key_code_(key)
  {
    mediator_=NULL;
  }
  virtual ~Component() {}
  
  virtual void Send() = 0;
  virtual void Recv() = 0;
  // ==重载
	bool operator==(const Component &component) const {
		return (key_code_ == component.key_code_) ;
	}

	// ！=重载
	bool operator!=(const Component &component) const {
		return (key_code_ != component.key_code_) ;
	}

  void set_mediator(Mediator *mediator){
    mediator_=mediator;
  }
protected:
  int key_code_;
  Mediator *mediator_;
};

ConcreteComponent1类 和 ConcreteComponen2类ConcreteComponenN 若干个类似的具体组件。这里只实现一个

#pragma once

#include "Component.h"
#include <iostream>
class ConcreteComponent1 : public Component
{
public:
    ConcreteComponent1() : Component(1) {}

public:
    void Send() override
    {
        std::cout << "Component " << key_code_ << "do send.\n";
        mediator_->Notify(this);
    }

    void Recv() override
    {
        std::cout << "Component " << key_code_ << "do recv.\n";
    }
};

ConcreteMediator类

#pragma once
#include "Component.h"
#include "Mediator.h"

class ConcreteMediator : public Mediator
{
public:
    ConcreteMediator(Component* component1,Component* component2):component1_(component1),component2_(component2){}
    virtual ~ConcreteMediator() {}
public:
    virtual void Notify(Component *sender) const override {
        if (sender == component1_)
        {
            component2_->Recv();
        }
        else if (sender == component2_)
        {
            component1_->Recv();
        }
    }

private:
    Component *component1_;
    Component *component2_;
};

main

#include "ConcreteComponent1.h"
#include "ConcreteComponent2.h"
#include "ConcreteMediator.h"

int main()
{
    Component *c1 = new ConcreteComponent1();
    Component *c2 = new ConcreteComponent2();
    ConcreteMediator *md = new ConcreteMediator(c1,c2);
    c1->set_mediator(md);
    c2->set_mediator(md);

    c1->Send();
    c2->Send();

    delete c1;
    delete c2;
    delete md;
    return 0;
}