设计模式之中介者模式

中介者模式定义：用一个中介者对象封装一系列的对象交互，中介者使各个对象不需要显示的相互作用，从而达到解耦的效果，而且可以独立的改变它们之间的交互

中介者模式的通用类图如下：

代码如下：

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

    protected Mediator mediator;

    public Colleague(Mediator mediator) {

        this.mediator = mediator;
    }
}

public class ConcreteColleague2 extends Colleague {

    /**
     * @param mediator
     */
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    // 自由方法
    public void selfMethod2() {

        // 处理自己的逻辑
    }

    // 依赖的方法
    public void depMethod2() {

        // 自己不能处理的逻辑委托给中介者处理
        super.mediator.doSomething2();
    }

}

public class ConcreteColleague1 extends Colleague {

    /**
     * @param mediator
     */
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    // 自由方法
    public void selfMethod1() {

        // 处理自己的逻辑
    }

    // 依赖的方法
    public void depMethod1() {

        //自己不能处理的逻辑，委托给中介者处理
        super.mediator.doSomething1();
    }

}

public abstract class Mediator {

    // 定义同事类
    protected ConcreteColleague1 c1;
    protected ConcreteColleague2 c2;

    // 定义逻辑
    public abstract void doSomething1();

    public abstract void doSomething2();

    public ConcreteColleague1 getC1() {
        return c1;
    }

    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }

    public ConcreteColleague2 getC2() {
        return c2;
    }

    public void setC2(ConcreteColleague2 c2) {
        this.c2 = c2;
    }

}

public class ConcreteMediator extends Mediator {

    /**
     * 
     */
    @Override
    public void doSomething1() {

        super.c1.selfMethod1();
        super.c2.selfMethod2();

    }

    /**
     * 
     */
    @Override
    public void doSomething2() {

        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }

}

通过中介者模式的通用代码可能开不出中介者模式到底有什么作用，其实使用中介者模式就是为了减少同事类之间的依赖，下面用一个进销存的例子说明一下中介者模式的作用。

未使用中介者模式时的类图如下：

通过类图其实我们就能够想到代码大概是什么样，那就是每个类都与其他两个有关联，关联越多耦合性越大，下面使用中介者模式修改一下，类图如下：

现在是通过一个中介者模式使其他三个类的耦合性降低，其他三个类之对中介者依赖，由中介者负责与其他类进行交互

代码如下：

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

    protected AbstractMediator mediator;

    public AbstractColleague(AbstractMediator mediator) {

        this.mediator = mediator;
    }
}

/**
 * 销售部门
 * 
 */
public class Sale extends AbstractColleague {

    /**
     * @param mediator
     */
    public Sale(AbstractMediator mediator) {
        super(mediator);
    }

    // 销售奔驰汽车
    public void sellBenz(int carNum) {

        super.mediator.exec("sell", 50);
    }

    // 打折销售
    public void offSale() {

        super.mediator.exec("offSale");
    }

    // 获取销售状态，用数字0-10来表示，0没有销售，10代表非常畅销
    public int getSaleStatus() {

        Random random = new Random(System.currentTimeMillis());

        int saleStatus = random.nextInt(10);

        System.out.println("汽车的销售情况：" + saleStatus);

        return saleStatus;
    }
}

/**
 * 采购部门
 * 
 */
public class Purchase extends AbstractColleague {

    /**
     * @param mediator
     */
    public Purchase(AbstractMediator mediator) {
        super(mediator);
    }

    // 采购奔驰汽车
    public void buyBenz(int carNum) {

        super.mediator.exec("buy", 20);
    }

    // 不在采购
    public void refuseBuyBenz() {

        System.out.println("不在采购汽车");
    }
}

/**
 * 库存部门
 * 
 */
public class Stock extends AbstractColleague {

    /**
     * @param mediator
     */
    public Stock(AbstractMediator mediator) {
        super(mediator);
        // TODO Auto-generated constructor stub
    }

    // 库存中默认100辆奔驰
    public static int DEFAULT_NUM = 100;

    // 库存汽车容量的上限
    public static final int MAX_NUM = 200;

    // 增加库存
    public void increase(int carNum) {

        DEFAULT_NUM += carNum;

        System.out.println("现在库存量：" + DEFAULT_NUM);
    }

    // 减少库存
    public void decrease(int catNum) {

        DEFAULT_NUM -= catNum;

        System.out.println("现在库存剩余量:" + DEFAULT_NUM);
    }

    // 获取库存量
    public int getStockNum() {

        return DEFAULT_NUM;
    }

    // 清理库存
    public void clearStock() {

        super.mediator.exec("clear", DEFAULT_NUM);
    }
}

/**
 * 抽象中介者
 * 
 */
public abstract class AbstractMediator {

    protected Sale sale;

    protected Purchase purchase;

    protected Stock stock;

    public AbstractMediator() {

        sale = new Sale(this);
        purchase = new Purchase(this);
        stock = new Stock(this);
    }

    protected abstract void exec(String str, Integer... num);
}

public class Mediator extends AbstractMediator {
    

    /**
     * @param str
     * @param num
     */
    @Override
    protected void exec(String str, Integer... num) {

        if ("buy".equals(str)) {
            this.buyBenz(num[0]);
        }

        if ("sell".equals(str)) {

            this.sellBenz(num[0]);
        }

        if ("offSale".equals(str)) {

            this.offSale();
        }

        if ("clear".equals(str)) {

            this.clearStock();
        }
    }

    // 清理库存
    public void clearStock() {

        // 通知销售
        super.sale.offSale();

        // 通知采购
        super.purchase.refuseBuyBenz();
    }

    // 打折销售
    private void offSale() {

        // 访问库存

        System.out.println("打折处理汽车数量:" + super.stock.getStockNum());
    }

    // 采购奔驰汽车
    private void buyBenz(int carNum) {

        // 询问销售部门汽车的销售情况，如果销售状态>8则进行采购，如果是0就暂时不采购，如果处于0--8之间则进行折半采购

        if (super.sale.getSaleStatus() == 0) {
            System.out.println("销售情况不好,暂时不采购");
        } else if (super.sale.getSaleStatus() < 8) {
            int halfNum = carNum / 2;
            System.out.println("销售情况不算理想，进行折半采购，采购汽车数量:" + halfNum);
            // 更新库存
            super.stock.increase(halfNum);

        } else {
            System.out.println("采购汽车:" + carNum + "量");
            // 更新库存
            super.stock.increase(carNum);
        }
    }

    // 销售奔驰汽车
    private void sellBenz(int carNum) {

        // 访问库存
        // 判断购买量和库存量
        if (super.stock.getStockNum() < carNum) {
            // 库存不够，通知采购部门进行采购

            super.purchase.buyBenz(carNum);
        }
        System.out.println("销售汽车：" + carNum + "辆");
        // 更新库存
        super.stock.decrease(carNum);
    }

}

public class Client {

    public static void main(String[] args) {

        // 创建一个中介者
        AbstractMediator mediator = new Mediator();
        // 采购人员采购汽车
        System.out.println("-----采购汽车------");
        Purchase purchase = new Purchase(mediator);
        purchase.buyBenz(20);

        // 销售人员销售汽车
        System.out.println("-----销售汽车------");
        Sale sale = new Sale(mediator);
        sale.sellBenz(50);

        // 清理库存
        System.out.println("-----清理库存-------");
        Stock stock = new Stock(mediator);
        stock.clearStock();
    }

}