设计模式18——举动型模式之中介者模式

设计模式18——行为型模式之中介者模式

类型：对象行为型模式

概述：

          面向对象编程，鼓励将行为分散到对象当中。这样的好处，增强对象的可复用性，但是带来的负面作用是，当多个对象交互时不可避免地会带来耦合性的大大提升。

          中介者模式的提出，就是为了解决多个对象相互交互时耦合性提升的问题。中介者模式主要通过将不同对象中涉及到交互的行为抽象出来，达到解耦的作用。这样，每个对象都只需要和中介者打交到即可，不用关注太多的对象。

         比如一个项目组，有一个项目经理和几个项目开发人员。如，开发人员需要开发资料，直接找项目经理要，项目经理去协调采购人员进行采购。又如，开发人员需要了解一个具体的需求，也直接找项目经理，然后项目经理去找销售人员了解更详细的需求。总之，开发人员，需要什么，都直接找项目经理就可以了，而不必关心去找谁，并如何跟对象交流。这样看来，开发人员就不会和其他对象产生交互，也就不会有很大的耦合性，比较纯粹，专注于自己的开发就好。这样，只要技术过关的人都可以充当开发人员，而不必要有各种关系，沟通技巧之类的。提高了开发人员的可复用性。

类图：

参与者：

1. Mediator，提供与Staff交互的接口。

2. ProjectManger，实现具体的接口来完成和不同职员的交互。

3. Staff，提供成员与Mediator交互的基本接口。
4. Developer，Buyer，Seller，完成各自的工作，然后通过Meditor的接口告诉具体的ProjectManager。

示例代码：

using System;
using System.Collections.Generic;
using System.Text;
namespace MediatorPattern
{
    abstract class Mediator
    {
        public abstract void Comunicate(string message, Staff colleague);
    }
    class ProjectManger : Mediator
    {
        private Developer staff1;
        private Buyer staff2;
        private Seller staff3;
        public Developer Staff1
        {
            set { staff1 = value; }
        }
        public Buyer Staff2
        {
            set { staff2 = value; }
        }
        public Seller Staff3
        {
            set { staff3 = value; }
        }
        public override void Comunicate(string message, Staff staff)
        {
            staff.Notify(message);
        }
    }
    abstract class Staff
    {
        protected Mediator mediator;
        public Staff(Mediator mediator)
        {
            this.mediator = mediator;
        }
        public abstract void Notify(string message);
    }
    class Developer : Staff
    {
        public Developer(Mediator mediator)
            : base(mediator)
        {
        }
        public void Ask(string message)
        {
            mediator.Comunicate(message, this);
        }
        public override void Notify(string message)
        {
            Console.WriteLine("开发人员完成开发任务" + message);
        }
    }
    class Buyer : Staff
    {
        public Buyer(Mediator mediator)
            : base(mediator)
        {
        }
        public void Send(string message)
        {
            mediator.Comunicate(message, this);
        }
        public override void Notify(string message)
        {
            Console.WriteLine("采购人员已经知道" + message);
        }
    }
    class Seller : Staff
    {
        public Seller(Mediator mediator)
            : base(mediator)
        {
        }
        public void Tell(string message)
        {
            mediator.Comunicate(message, this);
        }
        public override void Notify(string message)
        {
            Console.WriteLine("销售人员已经知道" + message);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ProjectManger mediator = new ProjectManger();
            Developer staff1 = new Developer(mediator);
            Buyer staff2 = new Buyer(mediator);
            Seller staff3 = new Seller(mediator);
            mediator.Staff1 = staff1;
            mediator.Staff2 = staff2;
            mediator.Staff3 = staff3;
            staff1.Ask("需要电路板");
            staff2.Send("已经采购电路板");
            staff1.Ask("需要客户需求");
            staff3.Tell("已经去调查");
        }
    }
}

1. 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
2. 一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。

3. 想定制一个分面在多个类中的行为，而又不想生成太多的子类。

优缺点：

1. 优点，降低对象之间的耦合度，提高对象的可复用用程度。

2. 缺点，如果交互的对象过多，中介者会非常复杂，难于管理。

参考资料：

1. 《设计模式——可复用面向对象软件基础》
2. 《大话设计模式》