DIV CSS 佈局教程網

深入理解 JavaScript:設計模式之橋接模式
編輯:關於JavaScript     

本篇解析橋接模式(Bridge)。它把抽象部分與實現部分分離,讓兩者都能各自獨立變化。

從一個常見的痛點說起

橋接模式最常被用在事件監控上。先看一段典型的直覺寫法:

addEvent(element, 'click', getBeerById);
function getBeerById(e) {
 var id = this.id;
 asyncRequest('GET', 'beer.uri?id=' + id, function(resp) {
    // Callback response.
    console.log('Requested Beer: ' + resp.responseText);
 });
}

問題在於:getBeerById 必須依賴瀏覽器的事件上下文才能運作,因為它內部用到了 this.id。一旦離開事件觸發的場合,這段程式就無從下手了。因此稍微有經驗的開發者通常會把它改成這樣:

function getBeerById(id, callback) {
 // 通過ID發送請求,然後返回數據
 asyncRequest('GET', 'beer.uri?id=' + id, function(resp) {
    // callback response
    callback(resp.responseText);
 });
}

實用多了:id 可以隨意傳入,還多了一個 callback 讓呼叫端自行決定如何處理結果。但這和橋接有什麼關係?答案就在下一段程式:

addEvent(element, 'click', getBeerByIdBridge);
function getBeerByIdBridge (e) {
 getBeerById(this.id, function(beer) {
   console.log('Requested Beer: '+beer);
 });
}

getBeerByIdBridge 就是我們刻意搭起的那座「橋」。它把抽象的 click 事件與具體的 getBeerById 連接起來,同時負責把事件來源元素的 ID、以及呼叫端自訂的回呼函式打包成參數送進去。事件機制不必知道請求怎麼發,請求函式也不必知道自己是誰觸發的——雙方透過這座橋溝通,各自都能獨立演進。

進階實戰:打造 XHR 請求隊列

接下來做一個更完整的例子。我們要構建一個佇列,裡頭存放多個 ajax 請求。使用佇列的原因是為了保證「先加入的先被處理」;同時我們希望它能隨時暫停、刪除、重試請求,並且支援對各個環節訂閱事件。

核心基礎函式

第一個是通用的異步請求封裝:

var asyncRequest = (function () {
    function handleReadyState(o, callback) {
        var poll = window.setInterval(
                      function () {
                         if (o && o.readyState == 4) {
                            window.clearInterval(poll);
                             if (callback) {
                                     callback(o);
                             }
                         }
                    },
                    50
                 );
    }

    var getXHR = function () {
        var http;
        try {
             http = new XMLHttpRequest;
             getXHR = function () {
                 return new XMLHttpRequest;
             };
        }

        catch (e) {
             var msxml = [
                        'MSXML2.XMLHTTP.3.0',
                        'MSXML2.XMLHTTP',
                        'Microsoft.XMLHTTP'
                     ];

             for (var i = 0, len = msxml.length; i < len; ++i) {
                     try {
                        http = new ActiveXObject(msxml[i]);
                        getXHR = function () {
                           return new ActiveXObject(msxml[i]);
                        };
                          break;
                        }
                        catch (e) { }
                }
        }
       return http;
    };

    return function (method, uri, callback, postData) {
        var http = getXHR();
        http.open(method, uri, true);
        handleReadyState(http, callback);
        http.send(postData || null);
        return http;
    };
})();

這個自執行函式返回一個通用的 Ajax 請求函式。getXHR 在首次呼叫時探測環境支援哪種 XHR 建構方式,並把自己覆寫成對應的簡化版本,後續呼叫就不必重複嘗試——這是典型的延遲初始化(lazy loading)技巧。

接著定義一個簡化原型擴充的輔助方法:

Function.prototype.method = function (name, fn) {
    this.prototype[name] = fn;
    return this;
};

再為陣列補上兩個方法,一個遍歷、一個篩選:

if (!Array.prototype.forEach) {
    Array.method('forEach', function (fn, thisObj) {
        var scope = thisObj || window;
        for (var i = 0, len = this.length; i < len; ++i) {
             fn.call(scope, this[i], i, this);
        }
    });
}

if (!Array.prototype.filter) {
    Array.method('filter', function (fn, thisObj) {
        var scope = thisObj || window;
        var a = [];
        for (var i = 0, len = this.length; i < len; ++i) {
                if (!fn.call(scope, this[i], i, this)) {
                    continue;
                }
                a.push(this[i]);
        }
        return a;
    });
}

由於部分新型瀏覽器(或某些類庫)已原生支援這兩個方法,所以要先判斷再決定是否補實作,避免覆蓋掉效能更好的原生版本。

觀察者系統

觀察者在佇列的事件流程中扮演關鍵角色,讓我們能在處理歷程(成功、失敗、掛起)中隨時訂閱:

window.DED = window.DED || {};
DED.util = DED.util || {};
DED.util.Observer = function () {
    this.fns = [];
}

DED.util.Observer.prototype = {
    subscribe: function (fn) {
        this.fns.push(fn);
    },

    unsubscribe: function (fn) {
        this.fns = this.fns.filter(
             function (el) {
             if (el !== fn) {
                    return el;
                }
             }
             );
             },
    fire: function (o) {
        this.fns.forEach(
             function (el) {
             el(o);
             }
             );
    }
};

佇列主體

先訂閱佇列的主要屬性與事件委託:

DED.Queue = function () {
    // 包含請求的隊列.
 this.queue = [];
    // 使用Observable對象在3個不同的狀態上,以便可以隨時訂閱事件
 this.onComplete = new DED.util.Observer;
    this.onFailure = new DED.util.Observer;
    this.onFlush = new DED.util.Observer;

    // 核心屬性,可以在外部調用的時候進行設置
 this.retryCount = 3;
    this.currentRetry = 0;
    this.paused = false;
    this.timeout = 5000;
    this.conn = {};
    this.timer = {};
};

接著透過 DED.Queue.method 的鏈式呼叫,一次為佇列掛上全部可用方法:

DED.Queue.
    method('flush', function () {
        // flush方法
  if (!this.queue.length > 0) {
             return;
        }

        if (this.paused) {
             this.paused = false;
             return;
        }

        var that = this;
        this.currentRetry++;
        var abort = function () {
            that.conn.abort();
            if (that.currentRetry == that.retryCount) {
                that.onFailure.fire();
                that.currentRetry = 0;
            } else {
                that.flush();
            }
        };

        this.timer = window.setTimeout(abort, this.timeout);
        var callback = function (o) {
            window.clearTimeout(that.timer);
            that.currentRetry = 0;
            that.queue.shift();
            that.onFlush.fire(o.responseText);
            if (that.queue.length == 0) {
                that.onComplete.fire();
                return;
            }

             // recursive call to flush
  that.flush();

        };

        this.conn = asyncRequest(
            this.queue[0]['method'],
            this.queue[0]['uri'],
            callback,
            this.queue[0]['params']
            );
    }).
    method('setRetryCount', function (count) {
        this.retryCount = count;
    }).
    method('setTimeout', function (time) {
        this.timeout = time;
    }).
    method('add', function (o) {
        this.queue.push(o);
    }).
    method('pause', function () {
        this.paused = true;
    }).
    method('dequeue', function () {
        this.queue.pop();
    }).
    method('clear', function () {
        this.queue = [];
    });

代碼看起來很多,折疊起來就會發現,實際上只是在佇列上定義了 flush、setRetryCount、setTimeout、add、pause、dequeue、clear 這七個方法。其中 flush 是核心:它為每個請求掛上逾時計時器,逾時則 abort 並依 retryCount 決定重試或觸發 onFailure;成功時清除計時器、把請求移出佇列、觸發 onFlush,若佇列已空則觸發 onComplete,否則遞迴呼叫自己處理下一筆。

基本呼叫

var q = new DED.Queue;
// 設置重試次數高一點,以便應付慢的連接
q.setRetryCount(5);
// 設置timeout時間
q.setTimeout(1000);
// 添加2個請求.
q.add({
    method: 'GET',
    uri: '/path/to/file.php?ajax=true'
});

q.add({
    method: 'GET',
    uri: '/path/to/file.php?ajax=true&woe=me'
});

// flush隊列
q.flush();
// 暫停隊列,剩余的保存
q.pause();
// 清空.
q.clear();
// 添加2個請求.
q.add({
    method: 'GET',
    uri: '/path/to/file.php?ajax=true'
});

q.add({
    method: 'GET',
    uri: '/path/to/file.php?ajax=true&woe=me'
});

// 從隊列裡刪除最後一個請求.
q.dequeue();
// 再次Flush
q.flush();

那麼,橋在哪裡?

上面的呼叫程式裡確實看不到橋。但把完整的頁面範例攤開來,就會發現橋無所不在:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"https://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
    <title>Ajax Connection Queue</title>
    <script src="utils.js"></script>
    <script src="queue.js"></script>
    <script type="text/javascript">
        addEvent(window, 'load', function () {
             // 實現.
 var q = new DED.Queue;
             q.setRetryCount(5);
             q.setTimeout(3000);
             var items = $('items');
             var results = $('results');
             var queue = $('queue-items');
             // 在客戶端保存跟蹤自己的請求
 var requests = [];
             // 每個請求flush以後,訂閱特殊的處理步驟
                q.onFlush.subscribe(function (data) {
                     results.innerHTML = data;
                      requests.shift();
                      queue.innerHTML = requests.toString();
                });
                // 訂閱時間處理步驟
                q.onFailure.subscribe(function () {
                     results.innerHTML += ' <span style="color:red;">Connection Error!</span>';
                });
                // 訂閱全部成功的處理步驟x
                 q.onComplete.subscribe(function () {
                     results.innerHTML += ' <span style="color:green;">Completed!</span>';
                });
             var actionDispatcher = function (element) {
                switch (element) {
                    case 'flush':
                         q.flush();
                         break;
                          case 'dequeue':
                              q.dequeue();
                            requests.pop();
                            queue.innerHTML = requests.toString();
                         break;
                          case 'pause':
                          q.pause();
                         break;
                          case 'clear':
                            q.clear();
                           requests = [];
                           queue.innerHTML = '';
                         break;
                 }
             };
             var addRequest = function (request) {
                var data = request.split('-')[1];
                q.add({
                    method: 'GET',
                    uri: 'bridge-connection-queue.php?ajax=true&s=' + data,
                    params: null
                    });
                    requests.push(data);
                    queue.innerHTML = requests.toString();
             };
             addEvent(items, 'click', function (e) {
                 var e = e || window.event;
                 var src = e.target || e.srcElement;
                 try {
                    e.preventDefault();
                 }
                 catch (ex) {
                     e.returnValue = false;
                }
                 actionDispatcher(src.id);
             });
             var adders = $('adders');
             addEvent(adders, 'click', function (e) {
                 var e = e || window.event;
                 var src = e.target || e.srcElement;
                 try {
                    e.preventDefault();
                }
                 catch (ex) {
                     e.returnValue = false;
                }
                 addRequest(src.id);
             });
        });
    </script>
    <style type="text/css" media="screen">
        body { font: 100% georgia,times,serif; }
        h1, h2 { font-weight: normal; }
        #queue-items { height: 1.5em; }
        #add-stuff { padding: .5em; background: #ddd; border: 1px solid #bbb; }
        #results-area { padding: .5em; border: 1px solid #bbb; }
    </style>
</head>
<body id="example">
    <div id="doc">
        <h1>異步聯接請求</h1>
        <div id="queue-items"></div>
        <div id="add-stuff">
             <h2>向隊列裡添加新請求</h2>
             <ul id="adders">
                <li><a href="#" id="action-01">添加 "01" 到隊列</a></li>
                <li><a href="#" id="action-02">添加 "02" 到隊列</a></li>
                <li><a href="#" id="action-03">添加 "03" 到隊列</a></li>
              </ul>
        </div>
        <h2>隊列控制</h2>
        <ul id='items'>
             <li><a href="#" id="flush">Flush</a></li>
             <li><a href="#" id="dequeue">出列Dequeue</a></li>
             <li><a href="#" id="pause">暫停Pause</a></li>
             <li><a href="#" id="clear">清空Clear</a></li>
        </ul>
        <div id="results-area">
             <h2>結果:</h2>
             <div id="results"></div>
        </div>
    </div>
</body>
</html>

在這個範例裡,你可以 flush 佇列、暫停、刪除請求、清空佇列。而橋接的體現在於:頁面上的 actionDispatcher 與 addRequest 就是兩座橋——它們把「使用者點了哪個連結」這個抽象事件,翻譯成佇列能理解的 q.add()、q.flush() 呼叫;而 onFlush / onFailure / onComplete 的訂閱,則把「佇列內部狀態變化」這個抽象訊息,橋接成具體的 DOM 更新。UI 與請求邏輯因此完全分開,任一方改動都不影響另一方。

總結

橋接模式的優點相當鮮明,主要可歸納為三點:

1. 分離介面與實現部分。一個實現不必不動地綁死在某個介面上,抽象類(函式)的實現可以在運行時刻決定,甚至可以在運行時刻替換。抽象與實現因此充分解耦,也有利於分層,从而产生結構更好的系統。

2. 提高可擴充性——新增一個抽象維度或一個實現維度,都不必回頭改動另一方。

3. 實現細節對客戶端透明,可以把實作細節藏在橋的後面。

當然它也有代價:大量的類別會導致開發成本上升,效能上也可能略有折損。是否值得,取決於你的系統是否真的存在兩個以上會獨立變化的維度。

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