DIV CSS 佈局教程網

深入理解 JavaScript:設計模式之中介者模式
編輯:關於JavaScript     

這是「深入理解 JavaScript 系列」中介者模式(Mediator)的解析篇。中介者模式用一個中介物件封裝一連串的物件互動,讓各物件不必顯式地互相參照,進而達到鬆耦合的效果,並且能夠獨立地替換它們之間的互動方式。

什麼是中介者模式

在軟體開發中,中介者屬於行為型設計模式。它提供一個統一介面,讓系統中不同的部分得以彼此溝通。一般來說,如果系統裡有大量子模組需要直接對話,就必須建立一個中央控制點,讓所有模組都透過它來交互;中介者模式的價值就在於:子模組之間不必互相認識,卻仍能協同運作,耦合度因此大幅降低。

最貼切的比喻莫過於機場的塔台調度系統。塔台就是那個中介者,所有飛機的起降都必須向塔台報備,而不是由飛機彼此喊話協調。中央調度點是整套系統的關鍵,在軟體設計裡扮演的正是中介者的角色。

偽代碼理解概念

先用一段偽代碼感受一下,此處的 app 命名空間就相當於中介者:

// 如下代碼是偽代碼,請不要過分在意代碼
// 這裡app命名空間就相當於扮演中介者的角色
var app = app || {};

// 通過app中介者來進行Ajax請求
app.sendRequest = function ( options ) {
    return $.ajax($.extend({}, options);
}

// 請求URL以後,展示View
app.populateView = function( url, view ){
  $.when(app.sendRequest({url: url, method: 'GET'})
     .then(function(){
         //顯示內容
    });
}

// 清空內容
app.resetView = function( view ){
   view.html('');
}

在 JavaScript 裡中介者其實非常常見,它相当于在观察者模式之上再加一层「訊息匯流排」的角色。差別在於,觀察者模式通常透過 pub/sub 的形式各自訂閱與發布,而中介者是由一個統一的中心來管理這些訂閱關係。以下是一個可實際運作的實作:

var mediator = (function () {
    // 訂閱一個事件,並且提供一個事件觸發以後的回調函數
    var subscribe = function (channel, fn) {
        if (!mediator.channels[channel]) mediator.channels[channel] = [];
        mediator.channels[channel].push({ context: this, callback: fn });
        return this;
    },

    // 廣播事件
    publish = function (channel) {
        if (!mediator.channels[channel]) return false;
        var args = Array.prototype.slice.call(arguments, 1);
        for (var i = 0, l = mediator.channels[channel].length; i < l; i++) {
             var subscription = mediator.channels[channel][i];
             subscription.callback.apply(subscription.context, args);
        }
        return this;
    };

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

} ());

它維護一個 channels 表,subscribe 負責把回呼函式放進指定通道,publish 則遍歷該通道底下所有訂閱並逐一觸發;另外還提供了 installTo,可以把 subscribe 與 publish 直接掛到任意物件上,讓該物件也能參與訊息交換。

呼叫方式相當直觀:

(function (Mediator) {

    function initialize() {
        // 默認值
        mediator.name = "dudu";

        // 訂閱一個事件nameChange
        // 回調函數顯示修改前後的信息
        mediator.subscribe('nameChange', function (arg) {
             console.log(this.name);
             this.name = arg;
             console.log(this.name);
        });
    }

    function updateName() {
        // 廣播觸發事件,參數為新數據
        mediator.publish('nameChange', 'tom'); // dudu, tom
    }

    initialize(); // 初始化
    updateName(); // 調用

})(mediator);

中介者與觀察者的差異

看到這裡,很多人會覺得中介者和觀察者幾乎一樣。兩者確實相似,但描述上有微妙的不同:

觀察者模式並沒有封裝約束的單一物件。相反地,Observer 與具体的 Subject 是「一起配合」來維護約束的,溝通發生在多個觀察者與多個具體類之間——每個具體類通常包含多個觀察者,而某個具體類裡的一個觀察者,本身也可能是另一個具體類。

中介者模式做的則不只是訊息分發,它承擔的是「維護這些約束」的職責。這正是兩者的分水嶺。

中介者與外觀模式的差異

另一組容易混淆的是中介者與外觀(Facade)。它們都對現有模組進行抽象,但出發點不同:中介者做的是模組「之間」的雙向溝通,是多向的;外觀模式只是為某個模組或系統定義一個簡單介面,不添加額外功能,系統中其他模組與這個外觀概念並沒有直接關聯,因此基本上是單向的。

完整實例:一個計分板遊戲

以下範例用「主客隊對戰計分」說明中介者如何協調多個角色:

<!doctype html>
<html lang="en">
<head>
    <title>JavaScript Patterns</title>
    <meta charset="utf-8">
</head>
<body>
<div id="results"></div>
    <script>
        function Player(name) {
             this.points = 0;
             this.name = name;
        }
        Player.prototype.play = function () {
             this.points += 1;
             mediator.played();
        };
        var scoreboard = {
             // 顯示內容的容器
             element: document.getElementById('results'),

             // 更新分數顯示
             update: function (score) {
                var i, msg = '';
                for (i in score) {
                    if (score.hasOwnProperty(i)) {
                        msg += '<p><strong>' + i + '<\/strong>: ';
                        msg += score[i];
                        msg += '<\/p>';
                    }
                }
                this.element.innerHTML = msg;
             }
        };

        var mediator = {

             // 所有的player
             players: {},

             // 初始化
             setup: function () {
                var players = this.players;
                players.home = new Player('Home');
                players.guest = new Player('Guest');
             },

             // play以後,更新分數
             played: function () {
                var players = this.players,
                      score = {
                        Home: players.home.points,
                        Guest: players.guest.points
                      };

                scoreboard.update(score);
             },

             // 處理用戶按鍵交互
             keypress: function (e) {
                e = e || window.event; // IE
                if (e.which === 49) { // 數字鍵 "1"
                    mediator.players.home.play();
                    return;
                }
                 if (e.which === 48) { // 數字鍵 "0"
                    mediator.players.guest.play();
                    return;
                }
             }
        };

        // go!
        mediator.setup();
        window.onkeypress = mediator.keypress;

        // 30秒以後結束
        setTimeout(function () {
             window.onkeypress = null;
            console.log('Game over!');
        }, 30000);
    </script>
</body>
</html>

Player 得分時不直接操作計分板,而是呼叫 mediator.played();中介者收到通知後,才去收集雙方分數並交給 scoreboard 更新畫面。Player 完全不知道 scoreboard 的存在,這就是解耦的實益。

總結

中介者模式適合用在「一組物件已定義良好,卻以複雜方式互相溝通」的場合。一般情況下它很容易導入系統,但也很容易被誤用。當系統出現多對多的複雜物件群時,先別急著套中介者模式,而應該先反思:是不是系統本身的設計出了問題?

另外要留意,中介者模式把互動的複雜性轉移成了中介者自身的複雜性,所以中介者物件往往會是全系統中最複雜的那一個。這是採用它必須付出的代價。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved