设计模式（二十一）中介者模式

中介者模式（Mediator），用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，比如 Form 对象或 Web 页面 aspx，已经想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合。

基本代码

// 抽象中介者类
abstract class Mediator
{
  // 定义一个抽象的发送消息方法，得到同事对象和发送消息
  public abstract void Send(string message, Colleague colleague);
}

// 抽象同事类
abstract class Colleague
{
  protected Mediator mediator;

  public Colleague(Mediator mediator)
  {
    // 构造方法，得到中介者对象
    this.mediator = mediator;
  }
}

// 具体中介者类
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);
    }
  }
}

//
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);
  }
}

// 客户端
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 UnitedNations
{
  // 声明
  public abstract void Declare(string message, Country colleague);
}

// 国家类，相当于抽象同事类
abstract class Country
{
  protected UnitedNations mediator;

  public Country(UnitedNations mediator)
  {
    // 构造方法，得到中介者对象
    this.mediator = mediator;
  }
}

// 联合国安理会，具体中介者类
class UnitedNationsSecurityCouncil : UnitedNations
{
  private USA Colleague1;
  private Ireq Colleague2;

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

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

  // 重写声明方法，实现两个对象间的通信
  public override void Declare(string message, Country colleague)
  {
    if(colleague == colleague1)
    {
      colleague2.GetMessage(message);
    }else
    {
      colleague1.GetMessage(message);
    }
  }
}

// 美国类
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);
  }
}

// 客户端
static void Main(string[] args)
{
  UnitedNationsSecurityCouncil UNNSC = new UnitedNationsSecurityCouncil();

  // 让两个具体同事类认识中介者对象
  USA c1 = new USA(UNNSC);
  Ireq c2 = new Ireq(UNNSC);

  // 让中介者认识各个具体同事类对象
  UNNSC.Colleague1 = c1;
  UNNSC.Colleague2 = c2;

  // 具体同事类对象的发送信息都是通过中介者转发
  c1.Declare(" ");
  c2.Declare(" ");

  Console.Read();
}

【总结】

中介者模式很容易在系统中应用，也很容易在系统中误用。当系统出现了 “多对多” 交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理。

中介者模式优点：

1、Mediator 的出现减少了各个 Colleague 的耦合，使得可以独立地改变和复用各个 Colleague 类和 Mediator。

2、由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

缺点：

由于 ConcreteMediator 控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个 ConcreteColleague 都复杂。