定义：（Mediator Pattern）
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使耦合松散，而且可以独立地改变它们之间的交互。
类图：
中介模式类图
启示：
最近两年，楼市疯狂，房价涨的离谱。为了预防楼市泡沫，中央出台一项项政策进行调控。在这样一个现实场景中，共有三个角色，买房者，房地产商，住建局。
买房者关注房地厂商的楼盘及房价，决定是否买房；
房地厂商关注买方市场，是否需要新建楼盘；
住建局就来协调买方与卖方市场，限购限建。
三个角色相互依赖，相互交互。耦合性比较紧，如何来解耦呢？中介者来帮忙。
中介是谁呢？就像你去买房，你肯定找中介啊，中介无所不知，他们即知道房地厂商有哪些楼盘，又了解买房市场的需求，同时也很熟悉国家的楼市政策。
代码：
/// <summary>
/// 抽象角色（模块）
/// 主要实现中介的依赖注入
/// </summary>
public abstract class Role
{
protected AbstractMediator mediator;
public Role(AbstractMediator mediator)
{
this.mediator = mediator;
}
}
/// <summary>
/// 购房（者）市场
/// </summary>
public class HomeBuyer : Role
{
private readonly string name = "购房市场：";
public HomeBuyer(AbstractMediator mediator)
: base(mediator)
{
}
private static int requirement = 800;//购房需求
public void BuyHouse(int num)
{
string rule = mediator.GetRule();
Console.WriteLine(name + "需要买房：" + num + "套");
if (rule != "LimitBuy")
{
requirement += num;
}
else
{
Console.WriteLine(name + "国家实例了限购政策，不允许购买");
}
}
/// <summary>
/// 签订购房合同
/// </summary>
/// <param name="num"></param>
public void SignAgreement(int num)
{
requirement -= num;
Console.WriteLine(string.Format("{0}成功购房{1}套", name, num));
}
public int GetRequirement()
{
return requirement;
}
}
/// <summary>
/// 房地产商
/// </summary>
public class Builder : Role
{
private readonly string name = "房地产商：";
public Builder(AbstractMediator mediator)
: base(mediator)
{
}
private static int houseNum = 1000;
public void BuildHouse()
{
int requirement = mediator.GetBuyRequirement();
if (houseNum < requirement)
{
//房源不够，立马新建
int needBuild = requirement - houseNum + 100;
Console.WriteLine(name + "建房：" + needBuild + "套");
houseNum += needBuild;
}
}
public void SaleHouse(int num)
{
if (houseNum < num)
{
string rule = mediator.GetRule();
if (rule != "LimitBuild")
{
Console.WriteLine(name + "房源不够，正在建设中");
this.BuildHouse();
}
}
else
{
houseNum -= num;
Console.WriteLine(name + "卖房：" + num + "套");
//告诉购房者签订合同
mediator.HomeBuyer.SignAgreement(num);
}
}
public int ShowHouseNum()
{
return houseNum;
}
}
/// <summary>
/// 住建局
/// </summary>
public class ControlCenter : Role
{
public ControlCenter(AbstractMediator mediator)
: base(mediator)
{
}
private readonly string name = "住建局：";
private static string rule;
/// <summary>
/// 当需大于供，限购
/// 当供大于需，限建
/// </summary>
public void Limit()
{
int requirement = mediator.GetBuyRequirement();
int buildingNum = mediator.GetCurrentHouseNumber();
string strs = string.Format("{0}目前购房需求为：{1}套;现有房源：{2}套。", name,requirement, buildingNum);
if (requirement > buildingNum)
{
Console.WriteLine(strs + "供小于需，开始实施限购政策");
rule = "LimitBuy";
}
else
{
Console.WriteLine(strs + "供大于需，开始实施限建政策");
rule = "LimitBuild";
}
}
public string ShowRule()
{
return rule;
}
/// <summary>
/// 抽象中介，定义各模块依赖的功能
/// </summary>
public abstract class AbstractMediator
{
/// <summary>
/// 使用属性注入
/// 因为中介可能只需要和部分角色（模块）交互
/// </summary>
public HomeBuyer HomeBuyer { get; set; }
public Builder HouseBuilder { get; set; }
public ControlCenter ControlCenter { get; set; }
/// <summary>
/// 获取购房需求
/// </summary>
/// <returns></returns>
public abstract int GetBuyRequirement();
/// <summary>
/// 获取房源数目
/// </summary>
/// <returns></returns>
public abstract int GetCurrentHouseNumber();
/// <summary>
/// 获取楼市政策
/// </summary>
/// <returns></returns>
public abstract string GetRule();
}
/// <summary>
/// 具体中介，实现各模块依赖的功能
/// </summary>
public class Mediator : AbstractMediator
{
public override int GetBuyRequirement()
{
return base.HomeBuyer.GetRequirement();
}
public override int GetCurrentHouseNumber()
{
return base.HouseBuilder.ShowHouseNum();
}
public override string GetRule()
{
return base.ControlCenter.ShowRule();
}
}
class Program
{
static void Main(string[] args)
{
AbstractMediator mediator = new Mediator();
//声明参与的角色
HomeBuyer buyer = new HomeBuyer(mediator);
Builder build = new Builder(mediator);
ControlCenter center = new ControlCenter(mediator);
//将需要的角色注入到中介
mediator.HouseBuilder = build;
mediator.HomeBuyer = buyer;
mediator.ControlCenter = center;
int initRequirement = mediator.GetBuyRequirement();
int initHousenum = mediator.GetCurrentHouseNumber();
Console.WriteLine(string.Format("目前购房需求为：{0}套;现有房源：{1}套。", initRequirement, initHousenum));
//买房300套
buyer.BuyHouse(300);
build.SaleHouse(300);
//国家住建局，考察市场
center.Limit();
//再买房1000套
buyer.BuyHouse(1000);
Console.ReadLine();
}
}
运行结果
参与角色：
● Mediator 抽象中介者角色
抽象中介者角色定义统一的接口，用于各同事角色之间的通信。
● Concrete Mediator 具体中介者角色
具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
● Colleague 同事角色
每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为（Self-Method），与其他的同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。
优缺点：
优点：中介者模式的优点就是减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合
缺点：中介者模式的缺点就是中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。
应用场景：
当类图中出现了蜘蛛网状结构时一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。
网友评论