设计模式--中介者模式

显然这样造成的后果是难以维护，为了避免这种情况，开发商引入了主板，由主板和各部件进行交互，统一协调，这样每个部件只需要把命令传给主板，由主板决定同哪个部件交互，然后接受主板返回的数据即可，不需要知道其他部件的存在：

在软件开发中，面向对象设计鼓励将行为分布到各个对象中。这种分布可能会导致对象间有许多连接。在最坏的情况下，每一个对象都知道其他所有对象。

将一个系统分割成许多对象通常可以增强可复用性，但是对象间相互连接的激增又会降低其可复用性。大量的相互连接使得一个对象似乎不太可能在没有其他对象的支持下工作—--系统表现为一个不可分割的整体（过度耦合）。而且对系统的行为进行任何较大的改动都十分困难。

这时可以像电脑开发商一样引入“主板”来解决，这就是中介者模式。

二、什么是中介者模式

如果在一个系统中对象之间存在多对多的相互关系（像没有引入主板前电脑各部件，它们被称为“同事类”），这时可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。通过引入中介者来简化对象之间的复杂交互，中介者模式是“迪米特法则”的一个典型应用。

中介者模式定义如下：

中介者模式(Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

中介者模式解决的困境就是多个对象之间的相互引用导致的紧耦合，通过引入一个中介者，原来互相引用的对象就相互解耦了，他们之间现在没有任何关系，只和中介者交互。

说白了中介者模式把对象之间的多对多关系转换成了同中介者类的一对多关系，从而降低耦合。

三、模式的结构

中介者模式UML类图如下：

中介者模式将一个网状的系统结构变成一个以中介者对象为中心的星形结构，在这个星型结构中，使用中介者对象与其他对象的一对多关系来取代原有对象之间的多对多关系。在中介者模式结构图中包含如下几个角色：

Mediator（抽象中介者）：中介者接口，该接口用于与各同事对象之间进行通信。
ConcreteMediator（具体中介者）：具体中介者实现对象，它维持对各个同事对象的引用，协调各个同事对象来实现协作行为。
Colleague（抽象同事类）：主要负责约束同事对象的类型，它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信。
ConcreteColleague（具体同事类）：在需要与其他同事通信的时候，就与持有的中介者通信，中介者负责与其他的同事进行交互；在具体同事类中实现了在抽象同事类中声明的抽象方法。

中介者模式的核心是中介者类，它承担了两方面的职责：

中转作用（结构性）：通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。
协调作用（行为性）：中介者可以更进一步的对同事之间的关系进行封装，同事可以一致的和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

四、典型代码

抽象中介者类典型代码如下：

public abstract class Mediator {
    public abstract void Send(String message, Colleague colleague);
}

具体中介者典型代码如下：

public class ConcreteMediator extends Mediator{
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public void setColleague1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    public void Send(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.Notify(message);
        } else if (colleague == colleague2){
            colleague1.Notify(message);
        } else {
            System.out.println("Error!");
        }
    }
}

抽象同事类典型代码：

public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public void Send(String message) {
        mediator.Send(message, this);
    }

    public abstract void Notify(String message);
}

具体同事类典型代码：

public class ConcreteColleague1 extends Colleague{
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    public void Notify(String message) {
        System.out.println("同事1得到信息：" + message);
    }
}

public class ConcreteColleague2 extends Colleague{
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void Notify(String message) {
        System.out.println("同事2得到信息：" + message);
    }
}

客户端测试：

public class MediatorPatternDemo {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.Send("How are you?");
        colleague2.Send("Fine, thank you. And you?");
        colleague1.Send("I'm fine. Thankes.");
    }
}

五、代码示例

5.1、标准中介者模式

假设使用电脑播放视频，把步骤分为如下几步：

光驱读取光盘内容，把读取到的内容传递给主板。
主板得到内容，交给cpu处理。
cpu处理完毕，把处理后的数据传递给主板。
主板把数据传递给显卡，显卡显示视频（忽略了显示器显示这个步骤）。

不使用中介者模式

public class CDDriver{
    private String data;
    private CPU cpu;

    public CDDriver(){
        this.cpu = new CPU();
    }

    public String getData() {
        return data;
    }

    public void readCD(){
        //逗号前是视频数据，逗号后是音频数据
        this.data = "Video Data,Sound Data";
        //然后CPU处理
        cpu.executeData(data);
    }
}

public class CPU{
    private VideoCard videoCard;
    private SoundCard soundCard;

    public CPU() {
        videoCard = new VideoCard();
        soundCard = new SoundCard();
    }

    public void executeData(String data){
        //分解数据，前面是视频数据，后面是音频数据
        String[] ss = data.split(",");
        String videoData = ss[0];
        String soundData = ss[1];
        videoCard.showData(videoData);
        soundCard.soundData(soundData);
    }
}

public class VideoCard{
    public void showData(String data){
        System.out.println("你正在观看的是：" + data);
    }
}

public class SoundCard{
    public void soundData(String data){
        System.out.println("你听到的声音是：" + data);
    }
}

这里设计的关联其实还算简单，并没有很复杂，但仍然会发现有以下问题：

系统耦合度高：每组件与多个其他组件之间产生相互关联和调用，若一个组件对象发生变化，需要跟踪与之有关联的其他所有组件并进行处理，组件之间的耦合度高。
组件的可重用性差：由于每一个组件和其他组件之间都具有很强的关联，若没有其他组件的支持，一个组件很难被另一个系统或模块重用，这些组件表现出来更像一个不可分割的整体，而在实际使用时，我们往往需要每一个组件都能够单独重用，而不是重用一个由多个组件组成的复杂结构。
系统的可扩展性差：如果在上述系统中增加一个新的组件类，则必须修改与之交互的其他组件类的源代码，将导致多个类的源代码需要修改，同样，如果要删除一个组件也存在类似的问题，这违反了“开闭原则”，可扩展性和灵活性欠佳。

使用中介者模式

抽象中介者：

public interface Mediator {
    void changed(Colleague colleague);
}

具体中介者主板类：

public class MainBoard implements Mediator {
    private CDDriver cdDriver;
    private CPU cpu;
    private VideoCard videoCard;
    private SoundCard soundCard;

    public void changed(Colleague colleague) {
        if(colleague == cdDriver){
            //表示光驱读取了数据
            this.operateCDDriverReadData((CDDriver)colleague);
        }else if(colleague == cpu){
            //表示CPU处理完数据
            this.operateCPU((CPU)colleague);
        }
    }

    public void setCdDriver(CDDriver cdDriver) {
        this.cdDriver = cdDriver;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public void setVideoCard(VideoCard videoCard) {
        this.videoCard = videoCard;
    }

    public void setSoundCard(SoundCard soundCard) {
        this.soundCard = soundCard;
    }

    public void operateCDDriverReadData(CDDriver cd){
        String data = cd.getData();
        this.cpu.executeData(data);
    }

    public void operateCPU(CPU cpu){
        String videoData = cpu.getVideoData();
        String soundData = cpu.getSoundData();
        this.videoCard.showData(videoData);
        this.soundCard.soundData(soundData);
    }
}

抽象同事类：

public abstract class Colleague {
    private final Mediator mediator;

    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }

    public Mediator getMediator(){
        return mediator;
    }
}

具体同事类：

public class CDDriver extends Colleague {
    private String data;

    public CDDriver(Mediator mediator) {
        super(mediator);
    }

    public String getData() {
        return data;
    }

    public void readCD(){
        //逗号前是视频数据，逗号后是音频数据
        this.data = "Video Data,Sound Data";
        //通知主板，自己的状态发生了变化
        this.getMediator().changed(this);
    }
}

public class CPU extends Colleague {
    private String videoData;
    private String soundData;

    public CPU(Mediator mediator) {
        super(mediator);
    }

    public String getVideoData() {
        return videoData;
    }

    public String getSoundData() {
        return soundData;
    }

    public void executeData(String data){
        //分解数据，前面是视频数据，后面是音频数据
        String[] ss = data.split(",");
        this.videoData = ss[0];
        this.soundData = ss[1];
        //通知主板，CPU的工作完成
        this.getMediator().changed(this);
    }
}

public class VideoCard extends Colleague{
    public VideoCard(Mediator mediator) {
        super(mediator);
    }

    public void showData(String data){
        System.out.println("你正在观看的是：" + data);
    }
}

public class SoundCard extends Colleague {
    public SoundCard(Mediator mediator) {
        super(mediator);
    }

    public void soundData(String data){
        System.out.println("你听到的声音是：" + data);
    }
}

客户端测试：

public class MediatorPatternDemo {
    public static void main(String[] args) {
        MainBoard mediator = new MainBoard();
        CDDriver cd = new CDDriver(mediator);
        CPU cpu = new CPU(mediator);
        VideoCard vc = new VideoCard(mediator);
        SoundCard sc = new SoundCard(mediator);

        mediator.setCdDriver(cd);
        mediator.setCpu(cpu);
        mediator.setVideoCard(vc);
        mediator.setSoundCard(sc);

        cd.readCD();
    }
}

引入中介者类后，再来看就会发现组件之间不再相互关联，系统之间耦合度降低，更易复用，扩展和维护，当然会发现系统相关变得复杂。

5.2、更广义的中介者模式

我们知道现实开发中，很多时候不会完全符合标准中介者模式，这时可以实际情况做一些变化，比如：

去掉同事对象的父类，这样可以让任意的对象，只要需要相互交互，就可以成为同事。
不定义Mediator接口，把具体的中介者实现成单例。
同事对象不再持有中介者对象，而是在具体处理方法里面去创建或者获取，或者从参数传入需要的同事对象。

现假设有有小说类和类别类，为此制定了一个书单，书单上有平时追更的小说，当小说完结了，也就追更完毕，就把小说从书单删除；还有可以将冷门类别的小说从书单删除......

这样实现：

public class Novel {
    private String novelId;
    private String novelName;
    private boolean finsh;

    public Novel(String novelId, String novelName){
        this.novelId = novelId;
        this.novelName = novelName;
    }

    public String getNovelId() {
        return novelId;
    }

    public String getNovelName() {
        return novelName;
    }

    public void setNovelId(String novelId) {
        this.novelId = novelId;
    }

    public void setNovelName(String novelName) {
        this.novelName = novelName;
    }

    public boolean isFinsh() {
        return finsh;
    }

    public void setFinsh(boolean finsh) {
        //如果完结了，就从书单删除
        if (finsh){
            NovelTypeMediator mediator = NovelTypeMediator.getInstance();
            mediator.removeNovel(novelId);
        }
        this.finsh = finsh;
    }
}

public class Type {
    private String typeId;
    private String typeName;
    private boolean unpopular;

    public Type(String typeId, String typeName) {
        this.typeId = typeId;
        this.typeName = typeName;
    }

    public void setTypeId(String typeId) {
        this.typeId = typeId;
    }

    public void setTypeName(String typeName) {
        this.typeName = typeName;
    }

    public String getTypeId() {
        return typeId;
    }

    public String getTypeName() {
        return typeName;
    }

    public boolean isUnpopular() {
        return unpopular;
    }

    public void setUnpopular(boolean unpopular) {
        if (unpopular){
            NovelTypeMediator mediator = NovelTypeMediator.getInstance();
            mediator.removeType(typeId);
        }
        this.unpopular = unpopular;
    }
}

public class NovelTypeRelation {
    private String id;
    private String novelId;
    private String typeId;

    public NovelTypeRelation(String id, String novelId, String typeId) {
        this.id = id;
        this.novelId = novelId;
        this.typeId = typeId;
    }

    public String getId() {
        return id;
    }

    public String getNovelId() {
        return novelId;
    }

    public String getTypeId() {
        return typeId;
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setNovelId(String novelId) {
        this.novelId = novelId;
    }

    public void setTypeId(String typeId) {
        this.typeId = typeId;
    }
}

public class NovelTypeMediator {
    private static NovelTypeMediator instance = new NovelTypeMediator();

    //书单
    private List<NovelTypeRelation> novelList = new ArrayList<NovelTypeRelation>();

    public static NovelTypeMediator getInstance(){
        return instance;
    }

    private NovelTypeMediator(){
        initData();
    }

    private void initData() {
        NovelTypeRelation n1 = new NovelTypeRelation("1", "1n", "1t");
        NovelTypeRelation n2 = new NovelTypeRelation("2", "2n", "1t");
        NovelTypeRelation n3 = new NovelTypeRelation("3", "3n", "2t");
        NovelTypeRelation n4 = new NovelTypeRelation("4", "4n", "2t");

        novelList.add(n1);
        novelList.add(n2);
        novelList.add(n3);
        novelList.add(n4);
    }

    /**
     * 展示书单
     */
    public void showNovelList(){
        for (NovelTypeRelation relation : novelList){
            System.out.println("小说编号是：" + relation.getNovelId() + "， 类型编号是：" + relation.getTypeId());
        }
    }

    /**
     * 删除小说
     * @param novelId
     */
    public void removeNovel(String novelId){
        for (Iterator<NovelTypeRelation> itr = novelList.iterator(); itr.hasNext();){
            NovelTypeRelation relation = itr.next();
            if (relation.getNovelId().equals(novelId)){
                itr.remove();
            }
        }
    }

    /**
     * 删除类型
     * @param typeId
     */
    public void removeType(String typeId){
        for (Iterator<NovelTypeRelation> itr = novelList.iterator(); itr.hasNext();){
            NovelTypeRelation relation = itr.next();
            if (relation.getTypeId().equals(typeId)){
                itr.remove();
            }
        }
    }
}

测试类：

public class Client {
    public static void main(String[] args) {
        NovelTypeMediator mediator = NovelTypeMediator.getInstance();

        //展示书单
        mediator.showNovelList();

        //完结
        Novel novel = new Novel("1n", "诛仙");
        novel.setFinsh(true);
        System.out.println("----------------一本小说完结后的书单------------------");
        mediator.showNovelList();

        //撤销分类2t
        Type type = new Type("2t", "奇异");
        type.setUnpopular(true);
        System.out.println("----------------删除一个分类后------------------");
        mediator.showNovelList();
    }
}

这里的Novel和Type都抽象父类，但依旧都可以当作同事类，NovelTypeMediator则为单例中介者。

六、优点和缺点

6.1、优点

中介者模式的主要优点如下：

中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构。
中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”。
复用性更好，中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使各个同事类可被重用，无须对同事类进行扩展。
将同事类的调用转移到中介者类中，简化了各同事类的设计和实现。

6.2、缺点

中介者模式的主要缺点如下：

中介者模式将交互的复杂性变为中介者的复杂性，在具体中介者类中包含了同事之间的交互细节，这可能使得中介者自身成为一个难于维护的庞然大物。

七、适用环境

在以下情况下可以使用中介者模式：

系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象。
交互的公共行为，如果需要改变行为则可以增加新的中介者类。

八、模式应用

MVC架构中控制器Controller作为一种中介者，它负责控制视图对象View和模型对象Model之间的交互。如在Struts中，Action就可以作为JSP页面与业务对象之间的中介者。

最后编辑于：2017.12.08 09:25:13

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,294评论 6赞 493
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,493评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,790评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,595评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,718评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,906评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,053评论 3赞 410
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,797评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,250评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,570评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,711评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,388评论 4赞 332
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,018评论 3赞 316
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,796评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,023评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,461评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,595评论 2赞 350

设计模式--中介者模式

设计模式--中介者模式

目录

一、引言

二、什么是中介者模式

三、模式的结构

四、典型代码

5.1、标准中介者模式

5.2、更广义的中介者模式

六、优点和缺点

6.1、优点

6.2、缺点

七、适用环境

八、模式应用

推荐阅读更多精彩内容