设计模式之行为模式（二）

调停者

当我们的模块中，对象与对象之间涉及到直接交互时（相互引用），我们可以将交互的信息封装在一个独立的对象中，这个对象又称为调停者。

面向对象的设计往往避免不了一组对象的相互交互，我需要你的信息，我也可以提供给你需要的的信息，譬如买房子的用户（A1）和卖房子的用户（B1），他们两者间相互协商，最后达成一个双方都较为满意的价格：
在这里插入图片描述
于是，当多个对象涉及到相互交互时，即有多个买房子的用户和多个卖房子的用户时，买房要货比商家，卖方根据多个买房的价格决定将房子卖给谁，然后关系图将变得交错纵杂：

在调停者模式中，它建议采用类似以中介的Mediator（调停者）来统一管理这些相互交互的信息：其中，涉及到的角色有：

抽象调停者(Mediator)角色：定义出同事对象到调停者对象的接口，其中主要方法是一个（或多个）事件方法。
具体调停者(ConcreteMediator)角色：实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类，并负责具体的协调各同事对象的交互关系。
抽象同事类(Colleague)角色：定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。
具体同事类(ConcreteColleague)角色：所有的具体同事类均从抽象同事类继承而来。实现自己的业务，在需要与其他同事通信的时候，就与持有的调停者通信，调停者会负责与其他的同事交互。

进一步分化：
在这里插入图片描述
这个似乎和其他文章稍微有点不同，他们可能只有右边或者左边的一部分，但道理差不多，只不过我这里有两个角色层次（买方和卖方）

代码示例

抽象中介

public interface AbstractMediator {
/**
 * 一个针对卖方的操作，一个针对买方的操作
 */
    void operateSelller();
    void operateBuyer();
}

某个具体中介

public class ConcreteMediator implements AbstractMediator {
     private ConcreteBuyer buyer;
     private ConcreteSeller seller;

    public void setBuyer(ConcreteBuyer buyer) {
        this.buyer = buyer;
    }

    public void setSeller(ConcreteSeller seller) {
        this.seller = seller;
    }


    @Override
    public void operateSelller() {
        String price = seller.getminPrice();
        buyer.getSellerPrice(price);
    }

    @Override
    public void operateBuyer() {
       String price = buyer.getWantPrice();
       seller.getBuyerPrice(price);
    }
}

抽象卖家，持有一个中介引用，方便指定想要的中介

public abstract class AbstractSeller {
    private AbstractMediator mediator;

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

   
    public AbstractMediator getMediator() {
        return mediator;
    }

}

具体卖家

public class ConcreteSeller extends AbstractSeller {
    private String minPrice;
    public ConcreteSeller(AbstractMediator mediator) {
        super(mediator);
    }
   //卖家的底线
    public String getminPrice() {
        return minPrice;
    }

    public void setminPrice(String minPrice) {
        this.minPrice = minPrice;
    }
    //接受中介发送的买家的价格信息
    public void getBuyerPrice(String price){
        System.out.println("卖方收到信息：买方希望的价格是"+price);
    }

}

抽象买家

public abstract class AbstractBuyer {
    private AbstractMediator mediator;

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

    public AbstractMediator getMediator() {
        return mediator;
    }
}

具体买家

public class ConcreteBuyer extends AbstractBuyer {
    private String wantPrice;
    public ConcreteBuyer(AbstractMediator mediator) {
        super(mediator);
    }
   //买家希望的价格
    public String getWantPrice() {
        return wantPrice;
    }

    public void setWantPrice(String wantPrice) {
        this.wantPrice = wantPrice;
    }
   //接收中介发送的卖家的价格信息
    public void getSellerPrice(String price){
        System.out.println("买方收到信息：卖家的价格："+price);
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        //指定中介
        AbstractMediator mediator = new ConcreteMediator();
        //买方和卖方选择中介
        AbstractBuyer buyer = new ConcreteBuyer(mediator);
        AbstractSeller seller = new ConcreteSeller(mediator);
        //中介接受委托
        ((ConcreteMediator) mediator).setBuyer((ConcreteBuyer)buyer);
        ((ConcreteMediator) mediator).setSeller((ConcreteSeller)seller);
        //买方想要120万元
        ((ConcreteBuyer) buyer).setWantPrice("120万元");
        //卖方的底线
        ((ConcreteSeller) seller).setminPrice("182万元");
        //中介通知买方卖方的价格
        mediator.operateBuyer();
        //中介通知卖方买方的价格
        mediator.operateSelller();
    }
}

设计模式之行为模式（二）

调停者

猜你喜欢