行为型---中介者模式（Mediator Pattern）

中介者模式的定义

中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。

 

中介者模式的结构

　　从生活中例子自然知道，中介者模式设计两个具体对象，一个是用户类，另一个是中介者类，根据针对接口编程原则，则需要把这两类角色进行抽象，所以中介者模式中就有了4类角色，它们分别是：抽象中介者角色，具体中介者角色、抽象同事类和具体同事类。中介者类是起到协调各个对象的作用，则抽象中介者角色中则需要保存各个对象的引用。有了上面的分析，则就不难理解中介者模式的结构图了，具体结构图如下所示：

为什么要使用中介者模式

　　在现实生活中，中介者的存在是不可缺少的，如果没有了中介者，我们就不能与远方的朋友进行交流了。而在软件设计领域，为什么要使用中介者模式呢？如果不使用中介者模式的话，各个同事对象将会相互进行引用，如果每个对象都与多个对象进行交互时，将会形成如下图所示的网状结构。

从上图可以发现，如果不使用中介者模式的话，每个对象之间过度耦合，这样的既不利于类的复用也不利于扩展。如果引入了中介者模式，那么对象之间的关系将变成星型结构，采用中介者模式之后会形成如下图所示的结构：

从上图可以发现，使用中介者模式之后，任何一个类的变化，只会影响中介者和类本身，不像之前的设计，任何一个类的变化都会引起其关联所有类的变化。这样的设计大大减少了系统的耦合度。

实现如下所示：

namespace ConsoleApplication1
{
    /// <summary>
    /// 通用抽象中介类
    /// </summary>
    public abstract class Mediator
    {
        //定义同事类
        protected ConcreteColleague1 c1;
        protected ConcreteColleague2 c2;
        public ConcreteColleague1 C1
        {
            get { return c1; }
            set { c1 = value; }
        }
        public ConcreteColleague2 C2
        {
            get { return c2; }
            set { c2 = value; }
        }
        //中介者模式的业务逻辑
        public abstract void doSomething1();
        public abstract void doSomething2();
    }
    public class ConcreteMediator : Mediator
    {
        public override void doSomething1()
        {
            //调用同事类的方法,只要是public方法都可以调用
            c1.selfMethod1();
            c2.selfMethod2();
        }
        public override void doSomething2()
        {
            //调用同事类的方法,只要是public方法都可以调用
            c1.selfMethod1();
            c2.selfMethod2();
        }
    }
    /// <summary>
    /// 抽象同事类
    /// </summary>
    public abstract class Colleague
    {
        protected Mediator mediator;
        public Colleague(Mediator _mediator)
        {
            this.mediator = _mediator;
        }
    }
    /// <summary>
    /// 具体同事类
    /// </summary>
    public class ConcreteColleague1 : Colleague
    {
        //通过构造函数传递中介者
        public ConcreteColleague1(Mediator _mediator)
            : base(_mediator)
        {
        }
        //自有方法
        public void selfMethod1()
        {
            //处理自己的业务逻辑
        }
        //依赖方法
        public void depMethod1()
        {
            //处理自己的业务逻辑
            //自己不能处理的业务逻辑,委托给中介者处理
            mediator.doSomething1();
        }
    }
    /// <summary>
    /// 具体同事类
    /// </summary>
    public class ConcreteColleague2 : Colleague
    {
        //通过构造函数传递中介者
        public ConcreteColleague2(Mediator _mediator)
            : base(_mediator)
        {
        }
        //自有方法
        public void selfMethod2()
        {
            //处理自己的业务逻辑
        }
        //依赖方法
        public void depMethod2()
        {
            //处理自己的业务逻辑
            //自己不能处理的业务逻辑,委托给中介者处理
            mediator.doSomething2();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

中介者模式的适用场景

 　　一般在以下情况下可以考虑使用中介者模式：

• 一组定义良好的对象，现在要进行复杂的相互通信。
• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

中介者模式的优缺点

中介者模式具有以下几点优点：

• 简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，将各个同事类解耦，使得系统变为松耦合。
• 提供系统的灵活性，使得各个同事对象独立而易于复用。

然而，中介者模式也存在对应的缺点：

• 中介者模式中，中介者角色承担了较多的责任，所以一旦这个中介者对象出现了问题，整个系统将会受到重大的影响。例如，QQ游戏中计算欢乐豆的程序出错了，这样会造成重大的影响。
• 新增加一个同事类时，不得不去修改抽象中介者类和具体中介者类，此时可以使用观察者模式和状态模式来解决这个问题。

应用一:

下面就以现实生活中打牌的例子来实现下中介者模式。在现实生活中，两个人打牌，如果某个人赢了都会影响到对方状态的改变。如果此时不采用中介者模式实现的话，则上面的场景的实现如下所示：

   // 抽象牌友类
    public abstract class AbstractCardPartner
    {
        public int MoneyCount { get; set; }
        public AbstractCardPartner()
        {
            MoneyCount = 0;
        }
        public abstract void ChangeCount(int Count, AbstractCardPartner other);
    }
    // 牌友A类
    public class ParterA : AbstractCardPartner
    {
        public override void ChangeCount(int Count, AbstractCardPartner other)
        {
            this.MoneyCount += Count;
            other.MoneyCount -= Count;
        }
    }
    // 牌友B类
    public class ParterB : AbstractCardPartner
    {
        public override void ChangeCount(int Count, AbstractCardPartner other)
        {
            this.MoneyCount += Count;
            other.MoneyCount -= Count;
        }
    }
    class Program
    {
        // A,B两个人打牌
        static void Main(string[] args)
        {
            AbstractCardPartner A = new ParterA();
            A.MoneyCount = 20;
            AbstractCardPartner B = new ParterB();
            B.MoneyCount = 20;
            // A 赢了则B的钱就减少
            A.ChangeCount(5, B);
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是25
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是15
           
            // B赢了A的钱也减少
            B.ChangeCount(10, A);
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount); // 应该是15
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是25
            Console.Read();        
        }
    }

上面确实完美解决了上面场景中的问题，并且使用了抽象类使具体牌友A和牌友B都依赖于抽象类，从而降低了同事类之间的耦合度。但是这样的设计，如果其中牌友A发生变化时，此时就会影响到牌友B的状态，如果涉及的对象变多的话，这时候某一个牌友的变化将会影响到其他所有相关联的牌友状态。例如牌友A算错了钱，这时候牌友A和牌友B的钱数都不正确了，如果是多个人打牌的话，影响的对象就会更多。这时候就会思考——能不能把算钱的任务交给程序或者算数好的人去计算呢，这时候就有了我们QQ游戏中的欢乐斗地主等牌类游戏了。所以上面的设计，我们还是有进一步完善的方案的，即加入一个中介者对象来协调各个对象之间的关联，这也就是中介者模式的应用了，具体完善后的实现代码如下所示：

namespace MediatorPattern
{
    // 抽象牌友类
    public abstract class AbstractCardPartner
    {
        public int MoneyCount { get; set; }
        public AbstractCardPartner()
        {
            MoneyCount = 0;
        }
        public abstract void ChangeCount(int Count, AbstractMediator mediator);
    }
    // 牌友A类
    public class ParterA : AbstractCardPartner
    {
        // 依赖与抽象中介者对象
        public override void ChangeCount(int Count, AbstractMediator mediator)
        {
            mediator.AWin(Count);
        }
    }
    // 牌友B类
    public class ParterB : AbstractCardPartner
    {
        // 依赖与抽象中介者对象
        public override void ChangeCount(int Count, AbstractMediator mediator)
        {
            mediator.BWin(Count);
        }
    }
    // 抽象中介者类
    public abstract class AbstractMediator
    {
        protected AbstractCardPartner A;
        protected AbstractCardPartner B;
        public AbstractMediator(AbstractCardPartner a, AbstractCardPartner b)
        {
            A = a;
            B = b;
        }
        public abstract void AWin(int count);
        public abstract void BWin(int count);
    }
    // 具体中介者类
    public class MediatorPater : AbstractMediator
    {
        public MediatorPater(AbstractCardPartner a, AbstractCardPartner b)
            : base(a, b)
        {
        }
        public override void AWin(int count)
        {
            A.MoneyCount += count;
            B.MoneyCount -= count;
        }
        public override void BWin(int count)
        {
            B.MoneyCount += count;
            A.MoneyCount -= count;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            AbstractCardPartner A = new ParterA();
            AbstractCardPartner B = new ParterB();
            // 初始钱
            A.MoneyCount = 20;
            B.MoneyCount = 20;
            AbstractMediator mediator = new MediatorPater(A, B);
            // A赢了
            A.ChangeCount(5, mediator);
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是25
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是15
            // B 赢了
            B.ChangeCount(10, mediator);
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是15
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是25
            Console.Read();
        }
    }
}

从上面实现代码可以看出，此时牌友A和牌友B都依赖于抽象的中介者类，这样如果其中某个牌友类变化只会影响到，只会影响到该变化牌友类本身和中介者类，从而解决前面实现代码出现的问题，具体的运行结果和前面实现结果一样。

 

应用二:

用中介模式实现一个简易的进销存系统

具体代码实现:

namespace ConsoleApplication1
{
    /// <summary>
    /// 抽象中介者
    /// </summary>
    public abstract class AbstractMediator
    {
        protected Purchase purchase;
        protected Sale sale;
        protected Stock stock;

        public AbstractMediator()
        {
            purchase = new Purchase(this);
            sale = new Sale(this);
            stock = new Stock(this);
        }
        //中介者最重要的方法叫做事件方法,处理多个对象之间的关系
        public abstract void execute(string strFun, params object[] arg);
    }

    /// <summary>
    /// 具体中介者
    /// </summary>
    public class Mediator : AbstractMediator
    {
        public override void execute(string strFun, params object[] arg)
        {
            switch (strFun)
            {
                case "purchase.buy": //采购电脑
                    this.buyComputer(Convert.ToInt32(arg[0]));
                    break;
                case "sale.sell": //销售电脑
                    this.sellComputer(Convert.ToInt32(arg[0]));
                    break;
                case "sale.offsell": //折价销售
                    this.offSell();
                    break;
                case "stock.clear": //清仓处理
                    this.clearStock();
                    break;
                default:
                    break;
            }
        }

        //采购电脑
        private void buyComputer(int number)
        {
            int saleStatus = sale.getSaleStatus();
            if (saleStatus > 80) //销售情况良好
            {
                Console.WriteLine("采购IBM电脑" + number + "台");
                stock.increase(number);
            }
            else  //销售情况不好
            {
                int buynumber = number / 2;
                Console.WriteLine("采购IBM电脑" + number + "台");
            }
        }
        //销售电脑
        private void sellComputer(int number)
        {
            if (stock.getStockNumber() < number)  //库存数量不够销售
            {
                purchase.buyIBMcomputer(number);
            }
            stock.decrease(number);
        }
        //折价销售电脑
        private void offSell()
        {
            Console.WriteLine("折价销售IBM电脑" + stock.getStockNumber() + "台");
        }
        //清仓处理
        private void clearStock()
        {
            //要求清仓销售
            sale.offSale();
            //要求采购人员不要采购
            purchase.refuseBuyIBM();
        }
    }


    /// <summary>
    /// 抽象同事类
    /// </summary>
    public abstract class AbstractColleague
    {
        protected AbstractMediator mediator;
        public AbstractColleague(AbstractMediator _mediator)
        {
            this.mediator = _mediator;
        }
    }

    /// <summary>
    /// 具体同事类--采购类
    /// </summary>
    public class Purchase : AbstractColleague
    {
        public Purchase(AbstractMediator _mediator)
            : base(_mediator)
        {

        }
        //采购IBM电脑
        public void buyIBMcomputer(int number)
        {
            mediator.execute("purchase.buy", number);
        }
        //不再采购IBM电脑
        public void refuseBuyIBM()
        {
            Console.WriteLine("不再采购IBM电脑");
        }
    }

    /// <summary>
    /// 具体同事类--库存管理类
    /// </summary>
    public class Stock : AbstractColleague
    {
        //模拟期初库存数
        private static int COMPUTER_NUMBER = 100;
        public Stock(AbstractMediator _mediator)
            : base(_mediator)
        {

        }
        //库存增加
        public void increase(int number)
        {
            COMPUTER_NUMBER = COMPUTER_NUMBER + number;
            Console.WriteLine("库存数量为:" + COMPUTER_NUMBER);
        }
        //库存减少
        public void decrease(int number)
        {
            COMPUTER_NUMBER = COMPUTER_NUMBER - number;
            Console.WriteLine("库存数量为:" + COMPUTER_NUMBER);
        }
        //获取库存数量
        public int getStockNumber()
        {
            return COMPUTER_NUMBER;
        }

        /*
         * 存货压力大了，
         * 就需要通知采购人员不要采购，
         * 销售人员要尽快销售
         */
        public void clearStock()
        {
            Console.WriteLine("清理存货是数量为:" + COMPUTER_NUMBER);
            mediator.execute("stock.clear");
        }
    }

    /// <summary>
    /// 具体同事类--销售管理类
    /// </summary>
    public class Sale : AbstractColleague
    {
        public Sale(AbstractMediator _mediator)
            : base(_mediator)
        {

        }
        //销售IBM电脑
        public void SellIBMComputer(int number)
        {
            mediator.execute("sale.sell",number);
            Console.WriteLine("销售IBM电脑" + number);
        }
        //反馈销售情况,0~100变化,0代表根本就没人买,100代表非常畅销
        public int getSaleStatus()
        {
            Random rand = new Random();
            int saleStatus = rand.Next(100);
            Console.WriteLine("IBM电脑的销售情况为:" + saleStatus);
            return saleStatus;
        }
        //折价处理
        public void offSale()
        {
            mediator.execute("sale.offsell");
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            AbstractMediator mediator = new Mediator();
            //采购人员采购电脑
            Console.WriteLine("---------采购人员采购电脑---------");
            Purchase purchase = new Purchase(mediator);
            purchase.buyIBMcomputer(100);
            //销售人员销售电脑
            Console.WriteLine("---------销售人员销售电脑---------");
            Sale sale = new Sale(mediator);
            sale.SellIBMComputer(1);
            //库存管理人员管理库存
            Console.WriteLine("---------库存管理人员管理库存---------");
            Stock stock = new Stock(mediator);
            stock.clearStock();
            Console.ReadLine();
        }
    }
}