**定义**:用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互交互，从而使其耦合松散，而且可以独立地改变他们之间的交互。 中介者就是将蜘蛛网状的用户关系模型改变成星形的用户关系模型。 ## 中介者的通用模型  **Mediator抽象中介者角色** --|抽象中介者角色定义统一的接口，用于各同事角色直接的通信。 **Concrete Mediator 具体中介者角色** --|具体中介者角色通过协调各同事角色实现协作行为，因此必须依赖于各个同事角色。 **Colleague 同事角色** --|每个同事角色都知道中介者角色，而且与其他同事角色通信时，一定要通过中介者角色协。 同事类行为分为两种： --|自发行为（self-Method）：一种同事本身的行为，例如改变对象本身的状态，处理自己的行为等。与其他同事类或中介者没有任何。 --|依赖方法(Dep-Method)：必须依赖中介者才能完成的行为。 ~~~ public class MediatorTest { public static void main(String[] args) { //创建出中介者，并执行逻辑操作。 Mediator mediator = new ConcreteMediator(); mediator.setC1(new Colleague1(mediator)); mediator.setC2(new Colleague2(mediator)); mediator.doSomething1(); } } abstract class Mediator{ //定义同事类 protected Colleague1 c1; protected Colleague2 c2; public Colleague1 getC1() { return c1; } public void setC1(Colleague1 c1) { this.c1 = c1; } public Colleague2 getC2() { return c2; } public void setC2(Colleague2 c2) { this.c2 = c2; } //中介者需要去完成的方法。 public abstract void doSomething1(); public abstract void doSomething2(); } class ConcreteMediator extends Mediator{ @Override public void doSomething1() { //调用同事类的方法，只要是public的方法都可以调用。 super.c1.depMethod(); super.c2.depMethod(); } @Override public void doSomething2() { super.c1.selfMethod(); super.c2.selfMethod(); } } abstract class Colleague{ //同事类需要与其他同事类进行交互的，就交给中介者来处理。 protected Mediator mediator; public Colleague(Mediator mediator) { this.mediator = mediator; } } class Colleague1 extends Colleague{ //通过构造函数，传递中介者。 public Colleague1(Mediator mediator) { super(mediator); } public void selfMethod(){ System.out.println("colleague1 所特有的方法..."); } public void depMethod(){ System.out.println("colleague1 需要中介者完成的方法..."); } } class Colleague2 extends Colleague{ //通过构造函数，传递中介者。 public Colleague2(Mediator mediator) { super(mediator); } public void selfMethod(){ System.out.println("colleague2 所特有的方法..."); } public void depMethod(){ System.out.println("colleague2 需要中介者完成的方法..."); } } ~~~ ## 一个例子: 一个公司有采购部门、销售部门、存货部门。他们之间存在着紧密的联系。 采购部门(Purchase)：根据销售情况、库存情况，负责采购不同的产品。     --|void buyIBMComputer(int number)     --|void refuseBuyIBM(); 销售部门(sale)：销售部门要反馈销售情况，畅销就多采购，滞销就不采购。    --|void sellIBMComputer(int number);    --|int getSaleStatus();    --|void offSale(); 存货部门(Stock)：根据销售情况，已经自身库存的数量，决定是否需要采购。    --|void increase(int number)    --|void decrease(int number)    --|int getStockNumber()    --|void clearStock(); **中介者模式的优点：** 减少类间的依赖，把原有的一堆多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖。同时降低了类间的耦合。  ~~~ public class MediatorT { public static void main(String[] args) { //创建中介者 AbstractMediator mediator = new ComMediator(); //销售者进行销售,100台电脑 Sale sale = new Sale(mediator); sale.sellIBMComputer(100); //获取库存状态 Stock stock = new Stock(mediator); System.out.println("库存状态.."+stock.getStock()); //采购者进行采购 Purchase purchase = new Purchase(mediator); purchase.buyIBMComputer(1000); //获取库存状态 System.out.println("库存状态.."+stock.getStock()); } } //抽象中介者类，用于将 abstract class AbstractMediator{ //库存部门 protected Stock stock = null; //销售部门 protected Sale sale = null; //采购部门。 protected Purchase purchase = null; public AbstractMediator() { this.sale = new Sale(this); this.purchase = new Purchase(this); this.stock = new Stock(this); } //定义一个中介者执行方法。共子类实现 public abstract void execute(String type,Object ...objects); } class ComMediator extends AbstractMediator{ @Override public void execute(String type, Object... objects) { //采购电脑，销售电脑，折价销售电脑，清仓处理 if(type.equalsIgnoreCase("purchase.buy")){ this.buyIBMComputer((Integer)objects[0]); }else if(type.equalsIgnoreCase("sale.sell")){ saleComputer((Integer)objects[0]); }else if(type.equalsIgnoreCase("sale.offSale")){ offSell(); }else if(type.equalsIgnoreCase("stock.clear")){ clearStock(); } } //清空仓库 private void clearStock(){ //清空仓库中的所有电脑。 super.stock.clearStock(); } //购买电脑 private void buyIBMComputer(int number){ //首先获取销售类，如果销售状态>80，就可以进行采购 int saleStatus = super.sale.getSaleStatus(); if(saleStatus > 80){ super.purchase.buyIBMComputer(number); //购买完成后，库存增加一定的电脑 super.stock.increase(number); }else{ //效益不好，折半采购 int buyNumber = number / 2; System.out.println("采购IBM电脑："+buyNumber+"台."); super.stock.increase(buyNumber); } } //销售电脑 private void saleComputer(int number){ //检查库存量 if(super.stock.getStock()<number){ //库存量不足，通知采购电脑 super.purchase.buyIBMComputer(number); } //将库存减去相应的电脑数 super.stock.decrease(number); } //折半销售电脑 private void offSell(){ System.out.println("折半销售电脑："+super.stock.getStock()+"台"); } } abstract class AbstractColleague{ //抽象的同事类，使得通过构造函数将中介者实例化 protected AbstractMediator abstractMediator; public AbstractColleague(AbstractMediator abstractMediator){ this.abstractMediator = abstractMediator; } } //库存部门 class Stock extends AbstractColleague{ //库存默认有10台电脑。 private static int COMPUTER_NUMBER = 100; public Stock(AbstractMediator abstractMediator) { super(abstractMediator); } //增加库存 public void increase(int number){ COMPUTER_NUMBER += number; } //获得库存量 public int getStock(){ return COMPUTER_NUMBER; } //减少库存 public void decrease(int number){ COMPUTER_NUMBER -= number; } //清空库存 public void clearStock(){ System.out.println("清空了仓库里的"+COMPUTER_NUMBER+"台电脑..."); COMPUTER_NUMBER = 0; } } //销售部门 class Sale extends AbstractColleague{ public Sale(AbstractMediator abstractMediator) { super(abstractMediator); } //购买电脑 public void sellIBMComputer(int number){ //通知中介者销售产品 super.abstractMediator.execute("sale.sell", number); System.out.println("销售了"+number+"台电脑。"); } //获取销售状态 public int getSaleStatus(){ //随机生成一个数字，表示销售状态 Random random = new Random(); int saleStatus = random.nextInt(100); return saleStatus; } //打折销售 public void offSale(){ //通知中介者打折销售 super.abstractMediator.execute("sale.offSale"); } } //采购部门 class Purchase extends AbstractColleague{ public Purchase(AbstractMediator abstractMediator) { super(abstractMediator); } //购买电脑。属于同事类的自身方法。无需借助Mediator。 public void buyIBMComputer(int number){ //通知中介者，购买number台电脑。 super.abstractMediator.execute("purchase.buy", number); } //拒绝购买电脑 public void refuseBuyIBM(){ System.out.println("拒绝购买电脑..."); } } ~~~