橋接模式(Bridge)的定義只有一句話:把抽象部分與它的實現部分分離開來,讓兩邊都能獨立變化。聽著抽象,但它其實是我們每天都在寫的東西,只是很少意識到自己正在用它。
先看一段再熟悉不過的代碼:
addEvent(element, 'click', getBeerById);
function getBeerById(e) {
var id = this.id;
asyncRequest('GET', 'beer.uri?id=' + id, function (resp) {
console.log('Requested Beer: ' + resp.responseText);
});
}
它有一個隱形前提:必須具備瀏覽器事件上下文,因為函數體依賴 this.id。一旦想在別的地方復用它,比如從定時器或另一段業務邏輯裡呼叫,就只能先偽造一個帶 id 的 this,非常别扭。
稍微有經驗的工程師會把它改成依賴注入的形式:
function getBeerById(id, callback) {
asyncRequest('GET', 'beer.uri?id=' + id, function (resp) {
callback(resp.responseText);
});
}
現在 id 可以從任何地方傳入,響應的處理方式也交給調用方決定,通用性大幅提升。但這跟橋接還有一步之遙。
關鍵在於:事件回調拿到的仍然是事件對象,而業務函數要的是 id。兩邊的接口對不上,需要一層轉接:
addEvent(element, 'click', getBeerByIdBridge);
function getBeerByIdBridge(e) {
getBeerById(this.id, function (beer) {
console.log('Requested Beer: ' + beer);
});
}
getBeerByIdBridge 就是那座橋。它把「點擊事件」這個抽象事件,和「按 ID 取數據」這套實現連接起來,同時完成參數提取與回調注入。抽象側關心的是「用戶點了什麼」,實現側關心的是「怎麼發請求、怎麼解析」,兩邊從此可以各自修改而不牽動對方。
上面那個例子略顯單薄,我們做一個更完整的:一個 Ajax 請求隊列,保證先入隊的請求先被處理,並且支持暫停、出隊、重試與事件訂閱。
首先是異步請求的封裝,順帶做了 XHR 對象的跨瀏覽器適配與延遲自替換優化:
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;
};
}());
接著補上兩個通用工具:一個往原型上掛方法的語法糖,以及數組的 forEach 與 filter 兼容實現(新版瀏覽器已原生支持時直接跳過)。
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 = []; // 等待中的請求
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 = {};
};
核心的 flush 方法負責取出隊首請求發送,並在超時時遞歸重試:
DED.Queue.
method('flush', function () {
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;
}
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 這七個方法。
上面的調用代碼裡確實看不到橋。真正的橋出現在把隊列接到頁面交互的那一層:
// 把 DOM 事件翻譯成隊列能理解的動作
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;
}
};
// 把自定義的 DOM 結構翻譯成隊列裡的一條請求
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);
});
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);
});
// 訂閱隊列的三種狀態,把結果畫回介面
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>';
});
q.onComplete.subscribe(function () {
results.innerHTML += ' <span style="color:green;">Completed!</span>';
});
看出來了嗎?actionDispatcher 和 addRequest 就是橋。左邊是頁面上那些五花八門的 DOM 結構與事件,右邊是隊列的七個方法,中間這層把「界面意圖」翻譯成「實現調用」。隊列不知道 DOM 的存在,DOM 也不必了解 XHR 的細節。
橋接模式的收益主要在三點:
代價也很直白:引入額外的抽象層意味著更多類與一層間接調用,開發成本上升,極端情况下對性能也有輕微影響。對於邊界清晰、兩軸都預期會持續演化的系統,這筆交易很划算;對於小工具,反而是過度設計。