设计模式之中介模式21

设计模式之中介模式21

背景

当有多个对象之间相互调用时，生成一个中介来协调处理各个类。举例：销售，采购，库存。销售时，如果有库存则销售，没库存则采购在销售。

抽象中介者（Mediator）角色：抽象中介者角色定义统一的接口用于各同事角色之间的通信。

具体中介者（Concrete Mediator）角色：具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。

同事（Colleague）角色：每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等等，这种方法叫做自发行为(Self-Method)，与其他的同事类或中介者没有任何的依赖；第二种是是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

类图

代码实现

抽象中介

public abstract class AbstractMediator {

    protected Stock stock;

    protected Purshase purshase;

    protected Sale sale;

    public AbstractMediator(){
        stock = new Stock(this);
        purshase = new Purshase(this);
        sale = new Sale(this);
    }

    public abstract void execute(String str, Object...objects);

}

抽象同事

public abstract class AbstractColleague {

    protected AbstractMediator mediator;

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

}

具体中介的实现

public class Mediator extends AbstractMediator{

    @Override
    public void execute(String str, Object... objects) {
        if("purchase.buy".equals(str)) {
            this.buy((Integer) objects[0]);
        }else if("sale.sell".equals(str)) {
            this.sell((Integer) objects[0]);
        }else if("sale.offsetsell".equals(str)) {
            this.offSell();
        }else if("stock.clear".equals(str)) {
            this.clearStock();
        }
    }

    public void buy(int number) {
        int saleState = this.sale.getSaleState();
        if(saleState > 80) {
            System.out.println("buy number:"+number);
        }else {
            number = number/2;
            System.out.println("buy number:"+number);
        }
        this.stock.increase(number);
    }

    public void sell(int number) {
        if(super.stock.getNumber() < number) {
            this.purshase.buy(number);
        }
        System.out.println("sell number:"+number);
        this.stock.decrease(number);
    }

    public void offSell() {
        System.out.println("off sell number:"+this.stock.getNumber());
        this.stock.decrease(stock.getNumber());
    }

    public void clearStock() {
        this.sale.offsetSell();
        this.purshase.refuseBuy();
    }
}

采购

public class Purshase extends AbstractColleague{

    public Purshase(AbstractMediator _mediator) {
        super(_mediator);
    }

    public void buy(int number) {
        this.mediator.execute("purchase.buy", number);
    }

    public void refuseBuy() {
        System.out.println("refuse buy");
    }
}

销售

import java.util.Random;

public class Sale extends AbstractColleague{

    public Sale(AbstractMediator _mediator) {
        super(_mediator);
    }

    public void sell(int number) {
        this.mediator.execute("sale.sell", number);
    }

    public void offsetSell() {
        this.mediator.execute("sale.offsetsell");
    }

    public int getSaleState() {
        Random random = new Random(System.currentTimeMillis());
        int saleState = random.nextInt(100);
        System.out.println("saleState:"+saleState);
        return saleState;
    }
}

库存

public class Stock extends AbstractColleague{

    public Stock(AbstractMediator _mediator) {
        super(_mediator);
    }

    public static int number = 100;

    public int getNumber() {
        return number;
    }

    public void increase(int _number) {
        number += _number;
        System.out.println("stock number:" + number);
    }

    public void decrease(int _number) {
        number -= _number;
        System.out.println("stock number:" + number);
    }

    public void clearStock() {
        System.out.println("clear stock");
        this.mediator.execute("stock.clear");
    }

}

运行结果

begin buy...
saleState:72
buy number:50
stock number:150

begin sell...
sell number:20
stock number:130

begin stock...
clear stock
off sell number:130
stock number:0
refuse buy