通俗易懂设计模式解析——中介者模式

前言

　　今天咱们一块儿看看中介者模式，怎么去理解这个模式呢？提及来也简单、好理解。生活中咱们租房常常都是经过中介来实现的。通常租房要么是房东直租要么是中介。那么今天要讲的中介者模式和租房的这个中介是否有关系呢？固然是有点关系的。中介者模式是用来下降多个对象和类之间的通讯复杂性。这种模式提供了一个中介类，这个类就来处理不一样类之间的通信。租房中介也是这个道理。复制与各个房东和租户之间的通信。将多对多简化成了一对多的关系。咱们下面来具体看看究竟是怎么回事吧!

中介者模式介绍

1、来由

在软件系统中常常会遇到多个对象相互关联相互引用依赖的状况。这样的话，若是遇到了需求变更将会影响到其余各个相互关联的对象变化。在这种状况下，就须要一个中介对象来管理处理这些多个对象之间的管理依赖关系。解决紧耦合、抵御一动牵全身的变化。

2、意图

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

3、案例图

4、中介者模式代码示例

看上面的案例图，咱们一块儿看看包含的四个部分：

抽象中介者：定义了各个同事之间交互须要的方法。

具体中介者：须要了解维护各个同事对象，而且负责协调各个具体同事之间的交互。

抽象同事类：约束具体同事类的类型、而且实现一些具体同事类之间的公共方法。

具体同事类：实现本身的业务。

咱们仍是回到开篇讲到的那个例子。关于租房中介的例子。加入没有租房中介。这里有六个房东须要出租房屋，房屋各不相同、各有各的特色、适合不同的人租住。这六个房东之间恰好有点联系。而后都在出租房屋。这时租客A来租房，看了一号房东的房子不满意、可是一号房东以为可让他去看看其余五个朋友的房间。而后开始联系他的五个朋友。这样运行下去好像有是没有什么问题的。可是其中二号房东若是房屋不出租或者出租出去了。也就是发生了变化。这是他则须要通知其余五个朋友，告诉他们不用再给他介绍租客了。这里就形成了中间一我的发生了变化，须要改动其余五我的。那么如何能够解决这种状况呢。咱们回到如今。把中介加进来、那六个房东都把房屋交给中介处理。租客A看房间一不满意直接经过中介看房间二。当房间二被出租了。中介也只须要通知房东二号、而后他们签定合同。下次还有人看房间就不会再看房间二了。这里一个出现了变化也就影响改变了一个。并不会影响其余另外五个房东。这个例子能够更好的帮助咱们理解中介者模式。咱们下面看两幅图。

图一：不采用中介的房东租房模式，多对多的网格。一动牵全身

图二：采用中介的租房模式，一对多、一个变更不影响其余

下面咱们看看代码如何实现中介者模式的吧。

namespace Mediator_Pattern
{
    class MediatorPattern
    {
    }

    /// <summary>
    /// 抽象中介者
    /// </summary>
    public abstract class Mediator
    {
        /// <summary>
        /// 定义与同事间的交互通讯 
        /// </summary>
        public abstract void Common(string type);
    }

    /// <summary>
    /// 抽象同事类
    /// </summary>
    public abstract class Colleague
    {
         

        /// <summary>
        /// 处理本身的事务（房东展现本身的房屋）
        /// </summary>
        public abstract void Handle();

    }

    /// <summary>
    /// 房屋中介
    /// </summary>
    public class HouseMediator : Mediator
    {
        /// <summary>
        /// 中介有全部房东的房屋信息
        /// </summary>
        private SmallHouseColleague SmallHouse;
        private TwoHouseColleague TwoHouse;
        private ThreeHouseColleague ThreeHouse;

        public void SetSmallHouse(SmallHouseColleague small) 
        {
            SmallHouse = small;
        }

        public void SetTwoHouse(TwoHouseColleague two)
        {
            TwoHouse = two;
        }
        public void SetThreeHouse(ThreeHouseColleague three)
        {
            ThreeHouse = three;
        }
        /// <summary>
        ///  
        /// </summary>
        /// <param name="colleague"></param>
        public override void Common(string  type)
        { 
            switch (type)
            {
                case "单间":
                    SmallHouse.Handle();
                    Console.WriteLine("若是能够就能够租房了!");
                    break;
                case "两居室":
                    TwoHouse.Handle();
                    Console.WriteLine("若是能够就能够租房了!");
                    break;
                case "三居室":
                    ThreeHouse.Handle();
                    Console.WriteLine("若是能够就能够租房了!");
                    break;
                default: 
                    Console.WriteLine($"{type}暂时没有房源!");
                    break;
            }
        }
    }

    /// <summary>
    /// 房东（小房间）
    /// </summary>
    public class SmallHouseColleague : Colleague
    {
         

        /// <summary>
        /// 展现单间
        /// </summary>
        public override void Handle()
        {
            Console.WriteLine( "单间——便宜整洁");
        }
    }

    /// <summary>
    /// 房东（两居室）
    /// </summary>
    public class TwoHouseColleague : Colleague
    { 

        /// <summary>
        /// 展现两居室
        /// </summary>
        public override void Handle()
        {
            Console.WriteLine("两居室——合适，靠谱");
        }
    }

    /// <summary>
    /// 房东（三居室）
    /// </summary>
    public class ThreeHouseColleague : Colleague
    { 

        /// <summary>
        /// 展现三居室
        /// </summary>
        public override void Handle()
        {
            Console.WriteLine("三居室——大气，宽松");
        }
    }
}复制代码

namespace Mediator_Pattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("一个租客看房：");
            ///初始化中介
            HouseMediator mediator = new HouseMediator();

            ///初始化房屋信息
            SmallHouseColleague smallHouseColleague = new SmallHouseColleague( );
            TwoHouseColleague twoHouseColleague = new TwoHouseColleague( );
            ThreeHouseColleague threeHouseColleague = new ThreeHouseColleague( );

            ///中介获取房屋信息
            mediator.SetSmallHouse(smallHouseColleague);
            mediator.SetTwoHouse(twoHouseColleague);
            mediator.SetThreeHouse(threeHouseColleague); 

            ///租户A须要两居室、提供看房
            mediator.Common("两居室");

            //租户B须要四居室、暂无房源
            mediator.Common("四居室");

        }
    }
}复制代码

使用场景及优缺点

1、使用场景

一、系统中对象间存在较为复杂引用，致使依赖关系和结构混乱而没法复用的状况。

二、想经过一个中间类来封装多个类的行为，可是又不想要太多的子类。

2、优势

一、松散耦合、将多个对象之间的联系紧耦合封装到中介对象中，作到松耦合。不会致使一动牵全身。

二、将多个对象之间的交互联系集中在中介对象中。发送变化仅需修改中介对象便可、提供系统的灵活性、使同事对象独立而易于复用。

三、符合迪米特原则。就是说一个对象应当对其余对象有尽量少的了解。减小各个对象之间的了解。

3、缺点

一、若是各个同事间的交互很是多而且复杂状况下，都交给中介者会致使中介者变得十分复杂，不易维护和管理。

总结

　　到这里中介者模式就介绍完了。中介者模式主要是实现将多个对象的相互依赖和关联解耦。用中介对象封装一些列的对象交互。将多对多的相互转换为多对一的相互做用。咱们再回忆咱们以前所讲到的外观模式和代理模式。好像三者之间有一些类似之处。那么咱们如何区分这三种模式呢？首先咱们看外观模式—外观模式注重的是简化接口，简化组件系统与外部程序的依赖关系。提供一个更高层次的统一接口，使子系统更加简便的使用。代理模式—注重的是对其余对象的访问控制、倾向于的是一对一的关系处理。中介者模式—注重的是将多对多的关系处理封装到一对多、经过一个中介者对象对多个对象之间的依赖进行解耦。

　　 这个社会是存在不公平的，不要抱怨，由于没有用！人老是在检讨中进步的！ 

　　 欢迎你们扫描下方二维码，和我一块儿踏上设计模式的闯关之路吧!