设计模式---中介模式

1.定义

中介模式：用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介模式中一个重要的角色就是中介者，它处于多个对象之间，处理对象之间多对多的关系。中介者就像我们日常生活的房产中介，负责处理房子买家和卖家的联系。

2.案例

在下面的案例中，有一下三种角色：
● Mediator 抽象中介者角色
抽象中介者角色定义统一的接口，用于各同事角色之间的通信。
● Concrete Mediator 具体中介者角色
具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
● Colleague 同事角色
每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。

/**
 * 抽象同事类
 */
public abstract class AbstractColleague {

    protected AbstractMediator mediator;

    public AbstractColleague(AbstractMediator mediator) {
        this.mediator = mediator;
    }

}

/**
 * 购买者
 */
public class Purchaser extends AbstractColleague {

    public Purchaser(AbstractMediator mediator) {
        super(mediator);
    }

    //买电脑
    public void buyComputer(int number) {
        mediator.execute("Purchaser.buy", number);
    }

    //拒绝买电脑
    public void refuseBuy() {
        System.out.println("拒绝买电脑...");
    }

}

/**
 * 销售员
 */
public class SaleClerk extends AbstractColleague {

    public SaleClerk(AbstractMediator mediator) {
        super(mediator);
    }

    //卖电脑
    public void sellComputer(int number) {
        mediator.execute("SaleClerk.sell", number);
    }

    //打折出售
    public void offSale() {
        mediator.execute("SaleClerk.offSell");
    }

    //获取销售情况
    public int getSaleStatus() {
        Random rand = new Random(System.currentTimeMillis());
        int saleStatus = rand.nextInt(100);
        return saleStatus;
    }

}

/**
 * 库存员
 */
public class StockClerk extends AbstractColleague {

    public StockClerk(AbstractMediator mediator) {
        super(mediator);
    }

    //设置电脑总数量为100
    private static int COMPUTER_NUMBER = 100;

    //增加库存
    public void increase(int number) {
        COMPUTER_NUMBER += number;
    }

    //减少库存
    public void decrease(int number) {
        COMPUTER_NUMBER -= number;
    }

    //获取库存数量
    public int getStockNumber() {
        return COMPUTER_NUMBER;
    }

    //清库存
    public void clearStock() {
        mediator.execute("StockClerk.clear");
    }

}

/**
 * 抽象中介者类
 */
public abstract class AbstractMediator {
    //购买者
    protected Purchaser purchaser;
    //销售员
    protected SaleClerk saleClerk;
    //库存员
    protected StockClerk stockClerk;

    //构造函数
    public AbstractMediator() {
        purchaser = new Purchaser(this);
        saleClerk = new SaleClerk(this);
        stockClerk = new StockClerk(this);
    }

    //中介者的执行方法
    public abstract void execute(String str, Object... objects);

}

//具体的中介者
public class Mediator extends AbstractMediator {

    @Override
    public void execute(String str, Object... objects) {
        if ("Purchaser.buy".equalsIgnoreCase(str)) {    //买电脑
            buyComputer((Integer) objects[0]);
        } else if ("SaleClerk.sell".equalsIgnoreCase(str)) {  //卖电脑
            sellComputer((Integer) objects[0]);
        } else if ("SaleClerk.offSell".equalsIgnoreCase(str)) {  //打折出售
            offSell();
        } else if ("StockClerk.clear".equalsIgnoreCase(str)) {  //清库存
            clearStock();
        }
    }

    //买电脑
    private void buyComputer(int number) {
        int saleStatus = saleClerk.getSaleStatus();
        if(saleStatus>80){  //销售情况良好
            System.out.println("采购电脑:" + number + "台");
            stockClerk.increase(number);
        }else{  //销售情况不好
            int buyNumber = number/2; //折半采购
            System.out.println("采购电脑："+ buyNumber + "台");
        }
    }

    //卖电脑
    private void sellComputer(int number) {
        if(stockClerk.getStockNumber() < number){ //库存数量不够销售
            purchaser.buyComputer(number);
        }
        stockClerk.decrease(number);
        System.out.println("卖电脑："+ number + "台");
    }

    //打折出售
    private void offSell() {
        System.out.println("折价销售电脑: "+ stockClerk.getStockNumber() + "台");
    }

    //清库存
    private void clearStock() {
        //要求清仓销售
        saleClerk.offSale();
        //要求采购人员不要采购
        purchaser.refuseBuy();
    }

}

public class MediatorPatternDemo {

    public static void main(String[] args) {
        AbstractMediator mediator = new Mediator();
        //采购人员采购电脑
        System.out.println("------采购人员采购电脑--------");
        Purchaser purchaser = new Purchaser(mediator);
        purchaser.buyComputer(100);

        //销售人员销售电脑
        System.out.println("\n------销售人员销售电脑--------");
        SaleClerk saleClerk = new SaleClerk(mediator);
        saleClerk.sellComputer(1);

        //库房管理人员管理库存
        System.out.println("\n------库房管理人员清库处理--------");
        StockClerk stockClerk = new StockClerk(mediator);
        stockClerk.clearStock();
    }

}

其中，购买者Purchaser、售货员SaleClerk和库存员StockClerk通过中介者Mediator来交互，而交互的工作由中介者来处理，购买者、售货员和库存员不需要知道其具体过程，这就达到解耦的目的。