中介者模式的定义
中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。中介者模式的结构
从生活中例子自然知道，中介者模式设计两个具体对象，一个是用户类，另一个是中介者类，根据针对接口编程原则，则需要把这两类角色进行抽象，所以中介者模式中就有了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游戏中计算欢乐豆的程序出错了，这样会造成重大的影响。
- 新增加一个同事类时，不得不去修改抽象中介者类和具体中介者类，此时可以使用观察者模式和状态模式来解决这个问题。
应用一:
下面就以现实生活中打牌的例子来实现下中介者模式。在现实生活中，两个人打牌，如果某个人赢了都会影响到对方状态的改变。如果此时不采用中介者模式实现的话，则上面的场景的实现如下所示：
View Code
View Code
// 抽象牌友类 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都依赖于抽象的中介者类，这样如果其中某个牌友类变化只会影响到，只会影响到该变化牌友类本身和中介者类，从而解决前面实现代码出现的问题，具体的运行结果和前面实现结果一样。
应用二:
用中介模式实现一个简易的进销存系统
具体代码实现:
View Code
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(); } } }