java-设计模式-中介者模式

设计模式-中介者模式
    用一个中介对象来封装一些了的对象交互。各对象不需要显示的相互引用。
    中介就是所有的调和者,符合最小知道原则，把交互功能几种在中介者身上。
    优点：
        灵活性高，因为将同事类进行了解耦，使其不必有关联性；
        降低了类的复杂度，将一对多转化成了一对一；
    缺点：
        过度集中化，这是中介者模式潜在的缺点。如果同事对象多了，交互也复杂了。
        那么这些交互全部集中到中介者对象中，会导致中介者对象十分臃肿，难以管理和维护。
    典型例子：
        电脑主板（主线） 与 CPU、银盘、内存等的交互。

来个类图：

中介需要知道所有的同事，同事也需要知道中介，同事有什么事情就告诉中介，中介会协调另外同事进行动作。

下面是一个模拟现实买房的例子来举例中介者模式：

1：先声明个房地产中介的接口

这个中介接口中定义了很多同事类还有很多动作


/**
 * 房地产中介 - 中介者
 * 中介就一个功能，沟通
 */
public abstract class RealtyMediator {
    //中介者都有同事者的信息
    //同事类 - 银行
    protected BankColleague bankColleague;
    //同事类 - 买房者
    protected BuyerColleague buyerColleague;
    //同事类 - 业主
    protected OwnerColleague ownerColleague;




    /**
     * 想售楼
     */
    abstract void wantToSale();

    /**
     * 想买楼
     */
    abstract void wantToBuy();

    /**
     * 同意卖楼
     */
    abstract void agreeToSale();

    /**
     * 想要贷款
     */
    abstract void wantToBorrow();

    /**
     * 同意贷款
     */
    abstract void agreeToBorrow();

    //get and set

    public BankColleague getBankColleague() {
        return bankColleague;
    }

    public void setBankColleague(BankColleague bankColleague) {
        this.bankColleague = bankColleague;
    }

    public BuyerColleague getBuyerColleague() {
        return buyerColleague;
    }

    public void setBuyerColleague(BuyerColleague buyerColleague) {
        this.buyerColleague = buyerColleague;
    }

    public OwnerColleague getOwnerColleague() {
        return ownerColleague;
    }

    public void setOwnerColleague(OwnerColleague ownerColleague) {
        this.ownerColleague = ownerColleague;
    }

}

2：具体的中介 - 某链J中介公司

此类实现了几个动作，比如 wantToSale（）想卖房方法是业主调用的，调用之后，是去通知买房的人的wantToBuy()方法


/**
 * 某链J房地产中介公司
 */
public class LjRealtyMediator extends RealtyMediator {

    @Override
    void wantToSale() {
        System.out.println("中介：有房源了，看看买房者想不想买");
        buyerColleague.wantToBuy();
    }

    @Override
    void wantToBuy() {
        System.out.println("中介：买房者想买了，再向业主确认下价格，看看卖不卖");
        ownerColleague.agreeToSale();
    }

    @Override
    void agreeToSale() {
        System.out.println("中介：业主同意卖方了，告诉买房者，让他准备钱");
        buyerColleague.wantToBorrow();
    }

    @Override
    void wantToBorrow() {
        System.out.println("中介：买房者想贷款，我去和银行说说");
        bankColleague.agreeToBorrow();
    }

    @Override
    void agreeToBorrow() {
        System.out.println("中介： 银行同意贷款了，告诉买房者准备材料");
        buyerColleague.ready();
    }
}

3：同事类-接口

此接口就一个构造函数

/**
 * 中介者同事类
 */
public abstract class Colleague {
    protected RealtyMediator realtyMediator;
    Colleague(RealtyMediator realtyMediator){
        this.realtyMediator = realtyMediator;
    }

}

4：具体的同事类：

银行同事类

有个同意贷款的方法，通知中介银行这边已经同意贷款了


/**
 * 银行 中介者模式同事类
 */
public class BankColleague extends Colleague {
    BankColleague(RealtyMediator realtyMediator) {
        super(realtyMediator);
        System.out.println("银行 和 中介 一直都是合作方，他们很早就认识了");
        realtyMediator.setBankColleague(this);
    }

    /**
     * 同意贷款
     */
    public void agreeToBorrow(){
        System.out.println("银行：同意贷款");
        realtyMediator.agreeToBorrow();
    }
}

业主同事类

有想卖房和同意卖房两个动作，都要告诉中介，让中介进行下一步


/**
 * 房屋出售的业主 - 中介者同事类
 */
public class OwnerColleague extends Colleague{
    OwnerColleague(RealtyMediator realtyMediator) {
        super(realtyMediator);
        System.out.println("业主 想卖房 ，认识了中介");
        realtyMediator.setOwnerColleague(this);
    }

    //业主的动作

    /**
     *  想售楼
     */
    public void wantToSale(){
        System.out.println("业主： 想要卖房");
        realtyMediator.wantToSale();
    }

    /**
     * 同意卖房
     */
    public void agreeToSale(){
        System.out.println("业主： 同意卖房");
        realtyMediator.agreeToSale();
    }

}

买房人的同事类


/**
 * 购买者 - 中介者模型同事类
 */
public class BuyerColleague extends Colleague {

    BuyerColleague(RealtyMediator realtyMediator) {
        super(realtyMediator);
        System.out.println("买房者:想买房 ，认识了中介");
        realtyMediator.setBuyerColleague(this);
    }

    /**
     * 想要买
     */
    public void wantToBuy(){
        System.out.println("买房者:想要买房");
        realtyMediator.wantToBuy();
    }

    /**
     * 想要贷款
     */
    public void wantToBorrow(){
        System.out.println("买房者:想要贷款");
        realtyMediator.wantToBorrow();
    }

    /**
     * 准备
     */
    public void ready(){
        System.out.println("买房者:材料正在准备中...");
    }
}

以上都声明完了，接下来，就是紧张的测试了，看看怎么用吧。

 public static void main(String[] args) {
        System.out.println("角色初始化...");
        //声明一个房地产中介
        RealtyMediator realtyMediator = new LjRealtyMediator();
        //银行
        Colleague bank = new BankColleague(realtyMediator);
        //买房者
        Colleague buyer = new BuyerColleague(realtyMediator);
        //业主 卖房者
        Colleague owner = new OwnerColleague(realtyMediator);
        System.out.println();
        System.out.println("------------故事要发生了---------------");
        System.out.println();
        //业主想卖房
        ((OwnerColleague) owner).wantToSale();
    }

运行结果：

角色初始化...
银行 和 中介 一直都是合作方，他们很早就认识了
买房者:想买房 ，认识了中介
业主 想卖房 ，认识了中介

------------故事要发生了---------------

业主： 想要卖房
中介：有房源了，看看买房者想不想买
买房者:想要买房
中介：买房者想买了，再向业主确认下价格，看看卖不卖
业主： 同意卖房
中介：业主同意卖方了，告诉买房者，让他准备钱
买房者:想要贷款
中介：买房者想贷款，我去和银行说说
银行：同意贷款
中介： 银行同意贷款了，告诉买房者准备材料
买房者:材料正在准备中...

例子已经演示完了，通过这个例子，我们也可以看到，同事类，其实也是我们的业务类，他只负责他自己的业务，他知道有个中介在那里，具体中介后面的操作，他也不关心，要他做的时候，中介自然会叫他做，

但是这个中介真的太辛苦了，太多事情要做了，如果他们的通讯种类再多几个的话，中介就太臃肿了，这也是中介者模式的弊端。

设计模式是种思路，它不一定很完美，但它真的很美。

xiaoluo5238

发布了60 篇原创文章 · 获赞 6 · 访问量 2万+

私信关注

java-设计模式-中介者模式

猜你喜欢