Java大话设计模式学习总结（二十五）---中介者模式

中介者模式（Mediator），用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
来自大话设计模式
举例：
当一个公司需要做一个网站，但是自己没有时间做，需要外包时，通常需要找一个外包公司来做，同时还需要找一个监理公司，负责查看做的进度以及效果，外包公司和监理公司之间的沟通，都需要通过公司来进行。这个情景就可以用中介模式来实现。

中介抽象类

abstract class AbstractCompany {
    AbstractMediator abstractMediator;
    public AbstractCompany(AbstractMediator abstractMediator) {
        this.abstractMediator = abstractMediator;
    }
    abstract void send(String content);
    abstract void get(String msg);
}

中介实现类

class ConcreteMediator extends AbstractMediator {
    
    OutsourcedCompany outsourcedCompany;
    SupervisionCompany supervisionCompany;

    @Override
    void send(String msg, AbstractCompany company) {
        if (company instanceof OutsourcedCompany) {
            System.out.println("中介收到来自外包公司的消息： " + msg + "，准备发送给监理公司");
            if (supervisionCompany != null) {
                supervisionCompany.get(msg);
            }
        } else if (company instanceof SupervisionCompany) {
            System.out.println("中介收到来自监理公司的消息： " + msg + "，准备发送给外包公司");
            if (outsourcedCompany != null) {
                outsourcedCompany.get(msg);
            }
        }
    }

    public void setOutsourcedCompany(OutsourcedCompany outsourcedCompany) {
        this.outsourcedCompany = outsourcedCompany;
    }

    public void setSupervisionCompany(SupervisionCompany supervisionCompany) {
        this.supervisionCompany = supervisionCompany;
    }

}

抽象同事类

abstract class AbstractCompany {
    AbstractMediator abstractMediator;
    public AbstractCompany(AbstractMediator abstractMediator) {
        this.abstractMediator = abstractMediator;
    }
    abstract void send(String content);
    abstract void get(String msg);
}

抽象同事类的实现类

class OutsourcedCompany extends AbstractCompany {
    public OutsourcedCompany(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }
    @Override
    void send(String content) {
       abstractMediator.send(content, this);
    }
    @Override
    void get(String msg) {
        System.out.println("外包公司收到消息：" + msg);
    }
}

class SupervisionCompany extends AbstractCompany {
    public SupervisionCompany(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }
    @Override
    void send(String content) {
       abstractMediator.send(content, this);
    }
    @Override
    void get(String msg) {
        System.out.println("监理公司收到消息：" + msg);
    }
}

主程序

class Test {
    public static void main(String[] args) {
        ConcreteMediator myCompany = new ConcreteMediator();
        OutsourcedCompany companyA = new OutsourcedCompany(myCompany);
        SupervisionCompany companyB = new SupervisionCompany(myCompany);
        
        myCompany.setOutsourcedCompany(companyA);
        myCompany.setSupervisionCompany(companyB);
        
        companyA.send("软件做完了，交给监理费检查吧！");
        System.out.println("======");
        companyB.send("检查完了，文档不够完善！");
    }
}
结果：
中介收到来自外包公司的消息： 软件做完了，交给监理费检查吧！，准备发送给监理公司
监理公司收到消息：软件做完了，交给监理费检查吧！
======
中介收到来自监理公司的消息： 检查完了，文档不够完善！，准备发送给外包公司
外包公司收到消息：检查完了，文档不够完善！

总结：

Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator，由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。但是由于ConcreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague类都复杂。所以中介者模式一般应用于一组以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多子类的场合。

Java大话设计模式学习总结（二十五）---中介者模式

总结：

猜你喜欢