DIV CSS 佈局教程網

設計模式之橋接模式:讓抽象與實現各自演化
編輯:JavaScript基礎知識     

橋接模式(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 取數據」這套實現連接起來,同時完成參數提取與回調注入。抽象側關心的是「用戶點了什麼」,實現側關心的是「怎麼發請求、怎麼解析」,兩邊從此可以各自修改而不牽動對方。

實戰:構建 XHR 請求隊列

上面那個例子略顯單薄,我們做一個更完整的:一個 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 的細節。

優缺點權衡

橋接模式的收益主要在三點:

  • 接口與實現解耦,抽象側的實現可以在運行時配置,甚至允許對象在運行時更換自己的實現,有利於分層並形成更清晰的系統結構。
  • 擴充成本可控,新增一維變化時不必觸發另一維的類爆炸。
  • 實現細節對客戶端透明,便於隱藏內部機制。

代價也很直白:引入額外的抽象層意味著更多類與一層間接調用,開發成本上升,極端情况下對性能也有輕微影響。對於邊界清晰、兩軸都預期會持續演化的系統,這筆交易很划算;對於小工具,反而是過度設計。

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