Question

介体设计模式如何，例如像这样的东西：

var mediator = (function(){

var _jobs = {};


function _extractedParams(arguments){
    var arr = [];
    if (arguments.length > 1){
        for (var i=1; i < arguments.length; i++) arr.push(arguments[i]);
    } 
    return arr;
}


function _defaultSubscribeCallback(){
    console.log("_defaultSubscribeCallback()");
}


return {

    subscribe: function(){
        var channel = arguments[0];

        if (!_jobs.hasOwnProperty(channel)) _jobs[channel] = [];

        _jobs[channel].push({
            originalParams: _extractedParams(arguments),
            callback: arguments[1] || _defaultSubscribeCallback
        });

    },

    publish: function(){
        var channel = arguments[0];

        if (!_jobs.hasOwnProperty(channel)) return 0;

        for (var i=0; i < _jobs[channel].length; i++){
            var subscription = _jobs[channel][i];

            subscription.callback.apply(this, subscription.originalParams);
        }

        return 1;  
    }

};

}());

var module1 = (function(){

    return {
        myFunction: function(){
           console.log(arguments[0]); //"Hello"
        }
    };

}());

mediator.subscribe("LOG_IN", module1.myFunction, "Hello");

var module2 = (function(){

    return {

        afterAuth: function(){
           mediator.publish("LOG_IN");
        }

    };

}());

//After user authentication
module2.afterAuth();

...比一个模块想要与另一个模块通信时简单地调用中间函数更好，例如这样的事情？：

var mediator = (function(){

    return {
        runFunction: function(){
            var params;

            if (arguments.length > 1){
                params = [];
                for (var i=1; i < arguments.length; i++) params.push(arguments[i]);
            }

            if (arguments[0] && typeof arguments[0] === "function") arguments[0](params);
        }
    };

}());

var module1 = (function(){

    return {
        myFunction: function(){
           console.log(arguments[0]); //"Hello"
        }
    };

}());

var module2 = (function(){

    return {

        afterAuth: function(){
           mediator.runFunction(module1.myFunction, "Hello");
        }

    };

}());

//After user authentication
module2.afterAuth();

虽然两种策略似乎都具有相同的好处（解耦等），但第一个示例通过保留_jobs中的订阅来产生开销（虽然我没有包含它，但我会提供{{} 1}}帮助减轻这种情况的方法，但它仍然是一个问题）;比第二个例子复杂得多;会导致性能略有下降;并且更有可能遇到问题。

我对Mediator模式的理解是什么？为什么它看起来像是一种不必要的复杂方式来实现简单的结果？为什么我希望所有这些订阅在unsubscribe()中浮动？

Answer 1

我现在意识到，第一个和第二个示例之间的重要区别在于，在第二个module2引用module1通过mediator.runFunction(module1.myFunction, "Hello");，而在第一个示例中，{{1} } 不引用module2，而是仅通过module1引用中介。显然，第二个示例，正如@ user943702所指出的那样，＆＃34;没有用处。＃34;

Answer 2

第一种方法实际上是观察者模式的一个示例，其中发布者发布和订阅者听，而在 Mediator Pattern 中，所有模块都与每个模块进行通信其他通过调解员。两种模式都有相同的好处，即去耦。在第二方法module1与module2 通信并且没有解耦（module1直接引用module2）并且它似乎非常适合应用Mediator Pattern，如果将来你要对模块进行大量的更改他们的接口。最好不要让模块担心接口，让调解员去做。关注点分离：）

中介模式与直接调用中间函数

2 个答案: