设计模式之中介者模式(十一)

转载地址  http://www.cnblogs.com/zxj159/p/3466115.html

一、引出模式

在生活中，当电脑缺少了一块主板，那会怎么样？如果有人这样问我的话，我就会马上跳出来说“这电脑肯定报废了”，当然这不是重点。假如少了主板电脑还可以用的话，想想，里面的CPU、显卡、声卡、光驱、硬盘等等，不是就要我们自己用线把它们连起来。想想就觉得头疼，那么现在你觉得主板在电脑里扮演着什么角色呢？

在软件的开发过程中，势必会碰到这样一种情况，多个类或多个子系统相互交互，而且交互很繁琐，导致每个类都必须知道他需要交互的类，这样它们的耦合会显得异常厉害。牵一发而动全身又不木有啊！

好了，既然问题提出来了，那有请我们这期的主角——中介者模式出场吧！

二、认识模式

1.模式定义

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

2.解决思路

出现问题的根本原因在于多个对象需要相互交互，导致了紧密耦合，不利于对象的修改和维护。

中介者模式的解决思路，就和“主板”一样，通过引入一个中介对象，让其他对象都只和这个中介者对象交互，而中介者对象是知道怎样和其他对象交互。这样一来，对象直接的交互关系就没有了，从而实现了松散耦合。

对于中介对象而言，所有相互交互的对象，都视为同事类，中介对象就是用来维护各个同事对象之间的关系，所有的同事类都只和中介对象交互，也就是说，中介对象是需要知道所有的同事对象的。

当一个同事对象自身发生变化时，它是不知道会对其他同事对象产生什么影响，它只需要通知中介对象，“我发生变化了”，中介对象会去和其他同事对象进行交互的。这样一来，同事对象之间的依赖就没有了。

有了中介者之后，所有的交互都封装在了中介对象里面，各个对象只需要关心自己能做什么就行，不需要再关系做了之后会对其他对象产生什么影响，也就是无需再维护这些关系了。

3.模式结构

  

Mediator：中介者接口。在里面定义了各个同事之间相互交互所需要的方法，可以是公共的方法，如Change方法，也可以是小范围的交互方法。

ConcreteMediator：具体的中介者实现对象。它需要了解并为维护每个同事对象，并负责具体的协调各个同事对象的交互关系。

Colleague：同事类的定义，通常实现成为抽象类，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象，也就是每个同事对象都会持有中介者对象的引用，这个功能可定义在这个类中。

ConcreteColleague：具体的同事类，实现自己的业务，需要与其他同事对象交互时，就通知中介对象，中介对象会负责后续的交互。

4.模式示例代码

internal class Program    {        private static void Main(string[] args)        {        }    }    /// <summary>    /// 同事类的抽象父类    /// </summary>    public abstract class Colleague    {        /// <summary>        /// 持有中介者对象，每一个同事类都知道它的中介者对象        /// </summary>        private Mediator mediator;        /// <summary>        /// 构造方法，传入中介者对象        /// </summary>        /// <param name="mediator">中介者对象</param>        protected Colleague(Mediator mediator)        {            this.mediator = mediator;        }        /// <summary>        /// 获取当前同事类对应的中介者对象        /// </summary>        /// <returns>对应的中介者对象</returns>        public Mediator GetMediator()        {            return mediator;        }    }    /// <summary>    /// 具体的同事类A    /// </summary>    public class ConcreteColleagueA : Colleague    {        /// <summary>        /// 调用父类的构造函数        /// </summary>        /// <param name="mediator"></param>        public ConcreteColleagueA(Mediator mediator):base(mediator)        {        }         /// <summary>        /// 执行某些业务功能        /// </summary>        public void SomeOperation()        {            //在需要跟其他同事通信的时候，通知中介者对象            base.GetMediator().Change(this);        }    }     /// <summary>    /// 具体的同事类B    /// </summary>    public class ConcreteColleagueB : Colleague    {        /// <summary>        /// 调用父类的构造函数        /// </summary>        /// <param name="mediator"></param>        public ConcreteColleagueB(Mediator mediator)            : base(mediator)        {        }        /// <summary>        /// 执行某些业务功能        /// </summary>        public void SomeOperation()        {            //在需要跟其他同事通信的时候，通知中介者对象            base.GetMediator().Change(this);        }    }     /// <summary>    /// 中介者，定义各个同事对象通信的接口    /// </summary>    public interface Mediator    {        void Change(Colleague colleague);    }     /// <summary>    /// 具体的中介者实现    /// </summary>    public class ConcreteMediator    {        /// <summary>        /// 持有并维护同事A        /// </summary>        private ConcreteColleagueA colleagueA;         /// <summary>        /// 持有并维护同事B        /// </summary>        private ConcreteColleagueB colleagueB;         /// <summary>        /// 设置中介者需要了解并维护的同事A对象        /// </summary>        /// <param name="colleague">同事A对象</param>        public void SetConcreteColleagueA(ConcreteColleagueA colleague)        {            colleagueA = colleague;        }         /// <summary>        /// 设置中介者需要了解并维护的同事B对象        /// </summary>        /// <param name="colleague">同事B对象</param>        public void SetConcreteColleagueB(ConcreteColleagueB colleague)        {            colleagueB = colleague;        }        public void Changed(Colleague colleague)        {            //某个同事类发生了变化，通常需要与其他同事交互            //具体协调相应的同事对象来实现协作行为        }    }

 

三、理解模式

1.中介者模式的功能

中介者的功能就是封装对象之间的交互。如果一个对象的操作会引起其他相关对象的变化，而这个对象又不希望自己来处理这些关系，那么就可以去找中介者，让它来处理这些麻烦的关系。

2.需要Mediator接口吗？

这一问题，首先得弄清楚接口用来干嘛的？接口是用来“封装隔离”的，Mediator接口用来封装中介者对象，使得中介者对象的客户对象跟具体的中介者实现对象分离开。

如果只有一个中介者对象，预期中也没打算扩展，那就可以不定义Mediator接口。

3.同事关系

在标准的中介者模式中，将使用中介者对象来交互的那些对象称为同事类，这是要求这些类都要继承自相同的类，也就是说它们算是兄弟对象。

4.同事和中介者的关系

在模式中，当一个同事对象发生变化时，需要主动通知中介者，让中介者去处理和其他同事对象的相关交互。

这就导致同事对象与中介对象必须有关系，同事对象需要知道中介对象，以便通知；中介对象需要知道同事对象，一边交互。所有它们的关系是相互依赖的。

5.如何实现同事和中介者的通信

一种方式是在Mediator接口中定义一个特殊的通知接口，作为一个通用的方法，让各个同事来调用这个方法。

另一种就是采用观察者模式，把Mediator实现成为观察者，各个同事对象实现为Subject.这些同事对象发生改变时，就会通知Mediator。

6.广义中介者

在实际开发中，经常会简化中介者模式，来是开发变得简单，比如有如下的简化。

l 通常会去掉同事对象的父类，这样可以让任意的对象，只需要有交互，就可以成为同事

l 通常不定义Mediator接口，把具体的中介者对象实现成为单例

l 同事对象不再持有中介者，而是在需要的时候直接获取中介者对象并调用；中介者也不再持有同事对象，而是在具体处理方法里面去创建，或获取，或从数据传入需要的同事对象。

经过这样的简化、变形的情况称为广义中介者。

7.何时选用中介者模式

如果一组对象之间的通信方式比较复杂，导致相互依赖，结构混乱，可以采用中介者模式

如果一个对象引用很多对象，并且跟这些对象交互，导致难以服用该对象

8.模式本质

中介者模式的本质在于“封装交互”

中介者模式的目的，就是封装多个对象的交互，这些交互的多在中介者对象里实现。

只要是实现封装对象的交互，就可以使用中介者模式，不必拘泥于模式结构。

9.相关模式

中介者模式和外观模式

外观模式多用于封装一个子系统内部的多个模块，目的是向子系统外部提供简单易用的接口。

中介者模式是提供多个平等的同事对象之间交互关系的封装，一般是用在内部实现上。

中介者模式和观察者模式

这两个模式可以组合使用。

中介者模式可以组合使用观察者模式，来实现当同事对象发生改变时，通知中介对象，让中介对象去进行与其他相关对象的交互。

 最后是一个中介者模式的实例：打开电脑看电影

比如有如下的交互：

1.首先光驱读取光盘上的数据，然后告诉主板，它的状态已经改变了。

2.主板得到光驱的数据，将数据交给CPU进行分析处理。

3.CPU处理完，将数据分成了视频数据和音频数据，通知主板，已将处理好了。

4.主板得到数据，将数据交给显卡和声卡进行输出。

代码示例：

class Program    {        static void Main(string[] args)        {            //1.创建中介者——主板对象            ConcreteMediator mediator = new ConcreteMediator();            //2.创建同事类            CDDriver cd = new CDDriver(mediator);            CPU cpu = new CPU(mediator);            VideoCard videocard = new VideoCard(mediator);            SoundCard soundcard = new SoundCard(mediator);            //3.让中介知道所有的同事            mediator.SetCDDriver(cd);            mediator.SetCPU(cpu);            mediator.SetVideoCard(videocard);            mediator.SetSoundCard(soundcard);            //4.开始看电影            cd.ReadCD();            Console.Read();        }    }    #region 同事抽象类    /// <summary>    /// 同事抽象类    /// </summary>    public abstract class Colleague    {        //持有中介者对象的引用，因为每个同事类都应该知道中介者对象        private Mediator mediator;        //构造函数，传入中介者对象        public Colleague(Mediator mediator)        {            this.mediator = mediator;        }        //得到当前同事类的中介者对象        public Mediator GetMediator()        {            return this.mediator;        }    }     #endregion    #region 同事具体类    /// <summary>    /// 光驱类    /// </summary>    public class CDDriver : Colleague    {        public CDDriver(Mediator mediator)            : base(mediator)        {        }        /// <summary>        /// 光驱读取出来的数据        /// </summary>        private string Data = null;        /// <summary>        /// 获取光驱读取出来的数据        /// </summary>        /// <returns></returns>        public string GetData()        {            return this.Data;        }        public void ReadCD()        {            //逗号前是视频数据，逗号后是声音数据            this.Data = "这是视频数据,这是声音数据";            //通知主板，自己的状态反生了改变            this.GetMediator().Change(this);        }    }    /// <summary>    /// CPU类    /// </summary>    public class CPU : Colleague    {        public CPU(Mediator mediator)            : base(mediator)        {        }        /// <summary>        /// 分解出来的视频数据        /// </summary>        private string videioData = null;        /// <summary>        /// 分解出来的视频数据        /// </summary>        private string soundData = null;        /// <summary>        /// 获取分解出来的视频数据        /// </summary>        /// <returns></returns>        public string GetVideioData()        {            return this.videioData;        }        /// <summary>        /// 获取分解出来的声音数据        /// </summary>        /// <returns></returns>        public string GetSoundData()        {            return this.soundData;        }        /// <summary>        /// 处理数据        /// </summary>        public void ExecuteData(string data)        {            string[] ss = data.Split(',');            this.videioData = ss[0];            this.soundData = ss[1];            //通知主板，CPU工作已完成            this.GetMediator().Change(this);        }    }    /// <summary>    /// 显卡类    /// </summary>    public class VideoCard : Colleague    {        public VideoCard(Mediator mediator)            : base(mediator)        {        }        /// <summary>        /// 显示视频数据源        /// </summary>        public void ShowData(string data)        {            Console.WriteLine("您正在看：" + data);        }    }    /// <summary>    /// 声卡类    /// </summary>    public class SoundCard : Colleague    {        public SoundCard(Mediator mediator)            : base(mediator)        {        }        /// <summary>        /// 显示声音数据源        /// </summary>        public void ShowData(string data)        {            Console.WriteLine("您正在听：" + data);        }    }     #endregion    #region 中介者抽象类    /// <summary>    /// 中介者抽象类    /// </summary>    public abstract class Mediator    {        public abstract void Change(Colleague colleague);    }     #endregion    #region 中介者具体类    /// <summary>    /// 中介者具体类    /// </summary>    public class ConcreteMediator : Mediator    {        private CDDriver cdDriver;        private CPU cpu;        private VideoCard video;        private SoundCard sound;        public void SetCDDriver(CDDriver cdDriver)        {            this.cdDriver = cdDriver;        }        public void SetCPU(CPU cpu)        {            this.cpu = cpu;        }        public void SetVideoCard(VideoCard video)        {            this.video = video;        }        public void SetSoundCard(SoundCard sound)        {            this.sound = sound;        }        public override void Change(Colleague colleague)        {            if (colleague == cdDriver)            {                openCDAndReadData((CDDriver)colleague);            }            else if (colleague == cpu)            {                OpenCPU((CPU)colleague);            }        }        /// <summary>        /// 打开CD，并读取数据        /// </summary>        /// <param name="cs"></param>        private void openCDAndReadData(CDDriver cs)        {            //获取光驱读取的数据            string data = cdDriver.GetData();            //把这些数据传递给CPU进行处理            this.cpu.ExecuteData(data);        }        /// <summary>        /// CPU处理        /// </summary>        /// <param name="cpu"></param>        private void OpenCPU(CPU cpu)        {            //获取数据            string videoData = cpu.GetVideioData();            string soundData = cpu.GetSoundData();            //显示数据            this.video.ShowData(videoData);            this.sound.ShowData(soundData);        }    }     #endregion