当前位置: 安卓之星 -> Java开发 -> 设计模式之中介者模式

设计模式之中介者模式

作者:网络 发表于: 2017-03-29 点击: 522 次

定义:用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互交互,从而使其耦合松散,而且可以独立地改变他们之间的交互。
中介者就是将蜘蛛网状的用户关系模型改变成星形的用户关系模型。

中介者的通用模型

中介者模式

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("拒绝购买电脑...");
    }
}

相关文章

相关文章

赶快留言冒泡

  • 评论 (0)
  • 引用通告 (0)
目前还没有任何评论.
目前还没有任何Trackbacks和Pingbacks.
吐个泡浮上去.