中介者模式(Mediator) [非原创--该篇文章大部分内容来自Yan YAN's Tech Space，底部附 C++实现]

重要概念

中介者模式的结构

       中介者模式又称为调停者模式，从类图中看，共分为3部分：

•  抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。
• 中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类。
• 同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有一个，这其实是现实的省略，在实际应用中，同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。

为什么要使用中介者模式

       一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下图中，有六个同事类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，同事类之间直接关联的设计是不好的。

        如果引入中介者模式，那么同事类之间的关系将变为星型结构，从图中可以看到，任何一个类的变动，只会影响的类本身，以及中介者，这样就减小了系统的耦合。一个好的设计，必定不会把所有的对象关系处理逻辑封装在本类中，而是使用一个专门的类来管理那些不属于自己的行为。

示例代码如下：

using System;
using System.Collections.Generic;
using System.Text;

namespace 中介者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteMediator m = new ConcreteMediator();

            ConcreteColleague1 c1 = new ConcreteColleague1(m);
            ConcreteColleague2 c2 = new ConcreteColleague2(m);

            m.Colleague1 = c1;
            m.Colleague2 = c2;

            c1.Send("吃过饭了吗?");
            c2.Send("没有呢，你打算请客？");

            Console.Read();
        }
    }

    abstract class Mediator
    {
        public abstract void Send(string message, Colleague colleague);
    }

    class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;
        private ConcreteColleague2 colleague2;

        public ConcreteColleague1 Colleague1
        {
            set { colleague1 = value; }
        }

        public ConcreteColleague2 Colleague2
        {
            set { colleague2 = value; }
        }

        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.Notify(message);
            }
            else
            {
                colleague1.Notify(message);
            }
        }
    }

    abstract class Colleague
    {
        protected Mediator mediator;

        public Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
    }

    class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Mediator mediator)
            : base(mediator)
        {

        }

        public void Send(string message)
        {
            mediator.Send(message, this);
        }

        public void Notify(string message)
        {
            Console.WriteLine("同事1得到信息:" + message);
        }
    }

    class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2(Mediator mediator)
            : base(mediator)
        {
        }

        public void Send(string message)
        {
            mediator.Send(message, this);
        }

        public void Notify(string message)
        {
            Console.WriteLine("同事2得到信息:" + message);
        }
    }
}

安理会例题

using System;
using System.Collections.Generic;
using System.Text;

namespace 中介者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            UnitedNationsSecurityCouncil UNSC = new UnitedNationsSecurityCouncil();

            USA c1 = new USA(UNSC);
            Iraq c2 = new Iraq(UNSC);

            UNSC.Colleague1 = c1;
            UNSC.Colleague2 = c2;

            c1.Declare("不准研制核武器，否则要发动战争！");
            c2.Declare("我们没有核武器，也不怕侵略。");

            Console.Read();
        }
    }

    //联合国机构
    abstract class UnitedNations
    {
        /// <summary>
        /// 声明
        /// </summary>
        /// <param name="message">声明信息</param>
        /// <param name="colleague">声明国家</param>
        public abstract void Declare(string message, Country colleague);
    }

    //联合国安全理事会
    class UnitedNationsSecurityCouncil : UnitedNations
    {
        private USA colleague1;
        private Iraq colleague2;

        public USA Colleague1
        {
            set { colleague1 = value; }
        }

        public Iraq Colleague2
        {
            set { colleague2 = value; }
        }

        public override void Declare(string message, Country colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.GetMessage(message);
            }
            else
            {
                colleague1.GetMessage(message);
            }
        }
    }

    //国家
    abstract class Country
    {
        protected UnitedNations mediator;

        public Country(UnitedNations mediator)
        {
            this.mediator = mediator;
        }
    }

    //美国
    class USA : Country
    {
        public USA(UnitedNations mediator)
            : base(mediator)
        {

        }
        //声明
        public void Declare(string message)
        {
            mediator.Declare(message, this);
        }
        //获得消息
        public void GetMessage(string message)
        {
            Console.WriteLine("美国获得对方信息：" + message);
        }
    }

    //伊拉克
    class Iraq : Country
    {
        public Iraq(UnitedNations mediator)
            : base(mediator)
        {
        }

        //声明
        public void Declare(string message)
        {
            mediator.Declare(message, this);
        }
        //获得消息
        public void GetMessage(string message)
        {
            Console.WriteLine("伊拉克获得对方信息：" + message);
        }

    }
}

C++ 版本：

#include <STRING>
#include <IOSTREAM>
using namespace std;


//国家 --- 抽象同事
class UnitedNations;
class Country
{
protected:
	UnitedNations& m_Mediator;
	
public:
	Country(UnitedNations& mediator) : m_Mediator(mediator){};
	virtual ~Country(){};
	virtual void Declare(string message) = 0;
};


//联合国机构---抽象中介者(Mediator)
class UnitedNations
{
public:
	virtual ~UnitedNations(){};
	/// <summary>
	/// 声明
	/// </summary>
	/// <param name="message">声明信息</param>
	/// <param name="colleague">声明国家</param>
	virtual void Declare(string message, Country* colleague) = 0;
};


//美国 --- 具体同事1
class USA : public Country
{
public:
	USA(UnitedNations& mediator) : Country(mediator){};
	//声明
public:
	void Declare(string message)
	{
		m_Mediator.Declare(message, this);
	};
	//获得消息
	void GetMessage(string message)
	{
		cout<<"美国获得对方信息："<<message<<endl;
	};
};


//伊拉克 --- 具体同事2
class Iraq : public Country
{
public:
	Iraq(UnitedNations& mediator) : Country(mediator){};
	//声明
	void Declare(string message)
	{
		m_Mediator.Declare(message, this);
	};
	
	//获得消息
	void GetMessage(string message)
	{
		cout<<"伊拉克获得对方信息："<<message<<endl;
	};
};


//联合国安全理事会---具体中介者(Mediator)
class UnitedNationsSecurityCouncil : public UnitedNations
{
public:
	UnitedNationsSecurityCouncil()
	{
		m_pColleague1 = NULL;
		m_pColleague2 = NULL;
	};
	
	void setCountries(USA* usa,Iraq* iraq)
	{
		m_pColleague1 = usa;
		m_pColleague2 = iraq;
	};
	
public:
	void Declare(string message, Country* colleague)
	{
		if (colleague == m_pColleague1)
		{
			m_pColleague2->GetMessage(message);
		}
		else
		{
			m_pColleague1->GetMessage(message);
		}
	};
	
private:
	USA*   m_pColleague1;
	Iraq*  m_pColleague2;
};


void main()
{
	UnitedNationsSecurityCouncil UNSC;
	USA usa(UNSC);
	Iraq iraq(UNSC);
	
	UNSC.setCountries(&usa,&iraq);


	usa.Declare("不准研制核武器，否则要发动战争！");
	iraq.Declare("我们没有核武器，也不怕侵略。");
}