Design Patterns

CHAPTER 7 ■ THE FACTORY PATTERN 103
extend(OfflineHandler, SimpleHandler);
OfflineHandler.prototype.request = function(method, url, callback, postVars) {
if(XhrManager.isOffline()) { // Store the requests until we are online.
this.storedRequests.push({
method: method,
url: url,
callback: callback,
postVars: postVars
});
}
else { // Call SimpleHandler's request method if we are online.
this.flushStoredRequests();
OfflineHandler.superclass.request(method, url, callback, postVars);
}
};
OfflineHandler.prototype.flushStoredRequests = function() {
for(var i = 0, len = storedRequests.length; i < len; i++) {
var req = storedRequests[i];
OfflineHandler.superclass.request(req.method, req.url, req.callback,
req.postVars);
}
};
OfflineHandler is a little simpler. Using the XhrMananger.isOffline method (which we will
talk more about in a moment), it ensures that the user is online before allowing the request to
be made, through SimpleHandler’s request method. It also executes all stored requests as soon
as it detects that the user is online.
Choosing Connection Objects at Run-Time
Here is where the factory pattern comes into play. Instead of requiring the programmer to
choose among these different classes at development time, when they have absolutely no idea
what the network conditions will be for any of the end users, you use a factory to choose the
most appropriate class at run-time. The programmer simply calls the factory method and uses
the object that gets returned. Since all of these handlers implement the AjaxHandler interface,
you can treat them identically. The interface remains the same; only the implementation changes:
/* XhrManager singleton. */
var XhrManager = {
createXhrHandler: function() {
var xhr;
if(this.isOffline()) {
xhr = new OfflineHandler();
}
else if(this.isHighLatency()) {
xhr = new QueuedHandler();
}