中介者模式 详解

定义

是一个行为设计模式，它容许咱们公开一个统一的接口，系统的不一样部分能够经过该接口进行通讯，而不须要显示的相互做用；

适用场景

• 若是一个系统的各个组件之间看起来有太多的直接关系，这个时候则须要一个中心控制点，以便各个组件能够经过这个中心控制点进行通讯；

该模式促进松散耦合的方式是：确保组件的交互是经过这个中心点来进行处理的，而不是经过显示的引用彼此；

角色

1. 抽象中介者（AbstractMediator）：定义中介者和各个同事者之间的通讯的接口；
2. 抽象同事者（AbstractColleague）：定义同事者和中介者通讯的接口，实现同事的公共功能；
3. 中介者（ConcreteMediator）：须要了解而且维护每一个同事对象，实现抽象方法，负责协调和各个具体的同事的交互关系；
4. 同事者（ConcreteColleague）：实现本身的业务，而且实现抽象方法，和中介者进行通讯；

其中同事者是多个同事相互影响的才能叫作同事者；

例子

好比系统和各个硬件，系统做为中介者，各个硬件做为同事者，当一个同事的状态发生改变的时候，不须要告诉其余每一个硬件本身发生了变化，只须要告诉中介者系统，系统会通知每一个硬件某个硬件发生了改变，其余的硬件会作出相应的变化；
这样，以前是网状结构，如今变成了以中介者为中心的星星结构；

---

基本实现代码1

var mediator = (function(){

    //存储可被广播或者监听的topic
    var topics = {};

    //订阅一个topic，提供一个回调函数，一旦topic被广播就执行该回调
    var subscribe = function (topic, fn) {
        if (!(topics[topic]))
        {
            topics[topic] = [];
        }
        topics[topic].push({context : this, callabck : fn});

        return this;
    };

    //发布/广播事件到程序的剩余部分
    var publish = function (topic) {
        var args;

        if (!topics[topic])
        {
            return false;
        }

        args = Array.prototype.slice.call(arguments, 1);
        for (var i = 0; i < topics[topic].length; i++)
        {
            var subscription = topics[topic][i];
            subscription.callabck.apply(subscription.context, args);
        }
        return this;
    };

    return {
        publish : publish,
        subscribe : subscribe,
        installTo : function (obj) {
            obj.subscribe = subscribe;
            obj.publish = publish;
        }
    };

}());

(function (Mediator) {
    function initialize() {
        mediator.name = "Li";

        /* 订阅一个事件nameChange 回调函数显示修改先后的消息 */
        mediator.subscribe("subscribe", function (arg) {
            console.log(this.name);
            this.name = arg;
            console.log(this.name);
        });
    }

    function publish() {
        //广播触发事件
        mediator.publish("subscribe","wang");
    }

    initialize();  //初始化
    publish();  //调用

})(mediator);

• 这段代码比较难理解，先是调用initialize函数将中介者的名字设置为Li，而后调用中介者mediator对象的subscribe方法，将topics[“subscribe”]中的对象绑定了回调函数fn，也就是以前输出的那个函数；
• 最后调用publish函数，获取topics下的topics[“subscribe”]对象，而且根据以前的参数，调用该对象的以前绑定的回调函数；

基本实现代码2

/** * 同事 * @param mediator * @constructor */
function Colleague(mediator) {
    this.mediator = mediator;

};

Colleague.prototype.getMediator = function () {
    return this.mediator;
};

Colleague.prototype.doOperation = function () {
    this.getMediator().change(this);
};

/** * 中介者（能够处理多个同事） * @param colleague1 * @param colleague2 * @constructor */
function Mediator(colleague1,colleague2) {
    this.colleague1 = colleague1;
    this.colleague2 = colleague2;
};

/* 当一个同事的状态发生改变的时候，由中介者获取到同事，并对该同事的状态进行改变 不须要和其余同事进行交互 */
Mediator.prototype.change = function (colleague) {
    colleague.doOperation();
};

Mediator.prototype.setColleague1 = function (colleague1) {
    this.colleague1 = colleague1;
    this.change(this.colleague2);
};

Mediator.prototype.setColleague2 = function (colleague2) {
    this.colleague2 = colleague2;
    this.change(this.colleague1);
};

• 这里function实现的是抽象对象，prototype后面实现的是具体对象；

---

优缺点

避免了同事之间的过分耦合，使得中介者能够独立的管理同事；

可是要注意使用中介者模式，由于这种模式最大的缺点就是：它会引来单一故障点，将Mediator放置于模块之间可能致使性能降低，由于有些模块可能须要直接跟另个模块进行通讯；因为松耦合的关系，很难经过牢牢关注广播来肯定一个系统若是做出反应；