行为型模式 - 中介者模式

1. 模式动机

• 在用户与用户直接聊天的设计方案中，用户对象之间存在很强的关联性，将导致系统出现如下问题：
• 系统结构复杂：对象之间存在大量的相互关联和调用，若有一个对象发生变化，则需要跟踪和该对象关联的其他所有对象，并进行适当处理。
• 对象可重用性差：由于一个对象和其他对象具有很强的关联，若没有其他对象的支持，一个对象很难被另一个系统或模块重用，这些对象表现出来更像一个不可分割的整体，职责较为混乱。
• 系统扩展性低：增加一个新的对象需要在原有相关对象上增加引用，增加新的引用关系也需要调整原有对象，系统耦合度很高，对象操作很不灵活，扩展性差。
• 在面向对象的软件设计与开发过程中，根据“单一职责原则”，我们应该尽量将对象细化，使其只负责或呈现单一的职责。
• 对于一个模块，可能由很多对象构成，而且这些对象之间可能存在相互的引用，为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，我们需要使用中介者模式，这就是中介者模式的模式动机。

2. 模式定义

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

3. 模式结构

中介者模式包含如下角色：

• Mediator: 抽象中介者

• ConcreteMediator: 具体中介者

• Colleague: 抽象同事类

• ConcreteColleague: 具体同事类

  

4. 时序图

5. 代码分析

5.1.c++实现

//colleague.h
#pragma once
#include <iostream>
#include <map>
using namespace std;
class Mediator;
class Colleague
{
public:
    virtual void receivemsg(string rev) = 0;
    virtual void sendmsg(int nId, string strSend) = 0;
    virtual void setMediator(Mediator *pMediator) = 0;
};

class ConcreteColleagueA : public Colleague
{
public:
    virtual void receivemsg(string rev);

    virtual void sendmsg(int nId, string strSend);

    virtual void setMediator(Mediator *pMediator);

private:
    Mediator *m_pMediator;
};

class ConcreteColleagueB : public Colleague
{
public:
    virtual void receivemsg(string rev);

    virtual void sendmsg(int nId, string strSend);

    virtual void setMediator(Mediator *pMediator);

private:
    Mediator *m_pMediator;
};

#include "Colleague.h"
#include "Mediator.h"

void ConcreteColleagueA::receivemsg(string rev)
{
    cout << "ConcreteColleagueA::receivemsg()" << rev << endl;
}

void ConcreteColleagueA::sendmsg(int nId, string strSend)
{
    m_pMediator->operation(nId, strSend);
}

void ConcreteColleagueA::setMediator(Mediator *pMediator)
{
    m_pMediator = pMediator;
}

void ConcreteColleagueB::receivemsg(string rev)
{
    cout << "ConcreteColleagueB::receivemsg()" << rev << endl;
}

void ConcreteColleagueB::sendmsg(int nId, string strSend)
{
    m_pMediator->operation(nId, strSend);
}

void ConcreteColleagueB::setMediator(Mediator *pMediator)
{
    m_pMediator = pMediator;
}

#pragma once
#include <iostream>
#include <map>
#include <string>
using namespace std;
class Colleague;
class Mediator
{
public:
    virtual void operation(int nId, string strColl) = 0;

    virtual void registerColleague(int nId, Colleague *pColleague) = 0;
};

class ConcreteMediator : public Mediator
{
public:
    void operation(int nId, string strColl);

    void registerColleague(int nId, Colleague *pColleague);

private:
    map<int, Colleague *> m_mpColleague;
};

#include "Mediator.h"
#include "Colleague.h"
void ConcreteMediator::operation(int nId, string strColl)
{
    cout << "Mediator::operation() id:" << nId << endl;
}

void ConcreteMediator::registerColleague(int nId, Colleague *pColleague)
{
    auto itr = m_mpColleague.find(nId);
    if (itr == m_mpColleague.end())
    {
        m_mpColleague.insert(make_pair(nId, pColleague));
        pColleague->setMediator(this);
    }
}

5.2.Golang实现

package main

import "fmt"

type Mediator interface {
	operation(nId int, str string)
	register(nId int, colleague Colleague)
}

type ConcreteMediator struct {
	mpColleague map[int]Colleague
}

func (c *ConcreteMediator) operation(nId int, str string) {
	if c.mpColleague == nil {
		c.mpColleague = make(map[int]Colleague)
	}
	if val, ok := c.mpColleague[nId]; ok {
		val.receivemsg(str)
	}
}

func (c *ConcreteMediator) register(nId int, colleague Colleague) {
	if c.mpColleague == nil {
		c.mpColleague = make(map[int]Colleague)
	}
	if _, ok := c.mpColleague[nId]; !ok {
		c.mpColleague[nId] = colleague
	}
}

type Colleague interface {
	receivemsg(str string)
	sendmsg(nId int, msg string)
	setMediator(mediator Mediator)
}

type ConcreteColleagueA struct {
	m_mediator Mediator
}

func (c *ConcreteColleagueA) receivemsg(str string) {
	fmt.Println("ConcreteColleagueA::receivemsg():" + str)
}

func (c *ConcreteColleagueA) sendmsg(nId int, msg string) {
	c.m_mediator.operation(nId, msg)
}

func (c *ConcreteColleagueA) setMediator(mediator Mediator) {
	c.m_mediator = mediator
}

type ConcreteColleagueB struct {
	m_mediator Mediator
}

func (c *ConcreteColleagueB) receivemsg(str string) {
	fmt.Println("ConcreteColleagueB::receivemsg():" + str)
}

func (c *ConcreteColleagueB) sendmsg(nId int, msg string) {
	c.m_mediator.operation(nId, msg)
}

func (c *ConcreteColleagueB) setMediator(mediator Mediator) {
	c.m_mediator = mediator
}

func main() {
	ConcreteColleagueA := new(ConcreteColleagueA)
	ConcreteColleagueB := new(ConcreteColleagueB)
	ConcreteMediator := new(ConcreteMediator)
	ConcreteMediator.register(1, ConcreteColleagueA)
	ConcreteMediator.register(2, ConcreteColleagueB)
	ConcreteColleagueA.setMediator(ConcreteMediator)
	ConcreteColleagueB.setMediator(ConcreteMediator)
	ConcreteColleagueA.sendmsg(2, "i am A")
	ConcreteColleagueB.sendmsg(1, "i am B")
}

6.模式分析

中介者模式可以使对象之间的关系数量急剧减少。

中介者承担两方面的职责：

• 中转作用（结构性）：通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，通过中介者即可。该中转作用属于中介者在结构上的支持。
• 协调作用（行为性）：中介者可以更进一步的对同事之间的关系进行封装，同事可以一致地和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

7.适用环境

在以下情况下可以使用中介者模式：

• 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
• 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象。
• 交互的公共行为，如果需要改变行为则可以增加新的中介者类。