中介者模式的定义
中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。
中介者模式的结构
从生活中例子自然知道，中介者模式设计两个具体对象，一个是用户类，另一个是中介者类，根据针对接口编程原则，则需要把这两类角色进行抽象，所以中介者模式中就有了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 = ;
}
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 = ;
AbstractCardPartner B = new ParterB();
B.MoneyCount = ;
// A 赢了则B的钱就减少
A.ChangeCount(, B);
Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是25
Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是15 // B赢了A的钱也减少
B.ChangeCount(, 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 = ;
}
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 = ;
B.MoneyCount = ;
AbstractMediator mediator = new MediatorPater(A, B);
// A赢了
A.ChangeCount(, mediator);
Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是25
Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是15
// B 赢了
B.ChangeCount(, 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[]));
break;
case "sale.sell": //销售电脑
this.sellComputer(Convert.ToInt32(arg[]));
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 > ) //销售情况良好
{
Console.WriteLine("采购IBM电脑" + number + "台");
stock.increase(number);
}
else //销售情况不好
{
int buynumber = number / ;
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 = ;
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();
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();
//销售人员销售电脑
Console.WriteLine("---------销售人员销售电脑---------");
Sale sale = new Sale(mediator);
sale.SellIBMComputer();
//库存管理人员管理库存
Console.WriteLine("---------库存管理人员管理库存---------");
Stock stock = new Stock(mediator);
stock.clearStock();
Console.ReadLine();
}
}
}