设计模式学习（三）

代理模式

定义：

是为一个对象提供一个代用品或占位符，以便控制对它的访问。

比如说如果想请明星来办一场商业演出，只能联系他的经纪人。经纪人会把商业演出的细节和报酬都谈好之后，再把合同交给明星签。

代理模式的关键是，当客户不方便直接访问一个对象或者不满足需要的时候，提供一个替身对象来控制对这个对象的访问，客户实际上访问的是替身对象。替身对象对请求做出一些处理之后，再把请求转交给本体对象。

举例：

小明决定给 A 送一束花来表白。刚好小明打听到 A 和他有一个共同的朋友 B，于是内向的小明决定让 B 来代替自己完成送花这件事情。

var Flower = function(){}; var xiaoming = {sendFlower: function( target ){var flower = new Flower();target.receiveFlower( flower ); }
};
var A = {receiveFlower: function( flower ){console.log( '收到花 ' + flower ); }
};
xiaoming.sendFlower( A );//接下来，我们引入代理 B，即小明通过 B 来给 A 送花: 
var Flower = function(){};var xiaoming = {sendFlower: function( target){ var flower = new Flower();target.receiveFlower( flower ); }
};
var B = {receiveFlower: function( flower ){A.receiveFlower( flower );}
};
var A = {receiveFlower: function( flower ){console.log( '收到花 ' + flower ); }
};xiaoming.sendFlower( B );

执行结果跟第一段代码一致，至此我们就完成了一个最简单的代理模式的编写。

目前看来代理模式毫无用处，它所做的只是把请求简单地转交给本体。

现在我们改变故事的背景设定，假设当 A 在心情好的时候收到花，小明表白成功的几率有 60%，而当 A 在心情差的时候收到花，小明表白的成功率无限趋近于 0。

小明跟 A 刚刚认识两天，还无法辨别 A 什么时候心情好。如果不合时宜地把花送给 A，花被直接扔掉的可能性很大，但是 A 的朋友 B 却很了解 A，所以小明只管把花交给 B，B 会监听 A 的心情变化，然后选择 A 心情好的时候把花转交给 A，代码如下:

var Flower = function(){};var xiaoming = {sendFlower: function( target){var flower = new Flower();target.receiveFlower( flower ); }
};
var B = {receiveFlower: function( flower ){A.listenGoodMood(function(){ A.receiveFlower( flower );}); }
};
var A = {
receiveFlower: function( flower ){// 监听 A 的好心情console.log( '收到花 ' + flower ); },listenGoodMood: function( fn ){setTimeout(function(){ // 假设 10 秒之后 A 的心情变好fn(); }, 10000 );}};xiaoming.sendFlower( B );

以上只是一个简单的代理模式说明，代理模式有多个变体种类。

代理种类：

• 虚拟代理：把一些开销很大的对象，延迟到真正需要它的时候才去创建。
• 缓存代理：可以为一些开销大的运算结果提供暂时的存储，在下次运算时，如果传递进来的参数跟之前一致，则可以直接返回前面存储的运算结果。
• 防火墙代理：控制网络资源的访问，保护主题不让“坏人”接近。
• 远程代理：为一个对象在不同的地址空间提供局部代表，在 Java 中，远程代理可以是另 一个虚拟机中的对象。
• 保护代理：用于对象应该有不同访问权限的情况。
• 智能引用代理：取代了简单的指针，它在访问对象时执行一些附加操作，比如计算一个 对象被引用的次数。
• 写时复制代理：通常用于复制一个庞大对象的情况。写时复制代理延迟了复制的过程，当对象被真正修改时，才对它进行复制操作。写时复制代理是虚拟代理的一种变体，DLL(操作系统中的动态链接库)是其典型运用场景。

其中虚拟代理和缓存代理比较常用。

虚拟代理例子——图片预加载:

图片预加载是一种常用的技术，如果直接给某个 img 标签节点设置 src 属性，由于图片过大或者网络不佳，图片的位置往往有段时间会是一片空白。

常见的做法是先用一张 loading 图片占位，然后用异步的方式加载图片，等图片加载好了再把它填充到 img 节点里，这种场景就很适合使用虚拟代理。

src 属性:

var myImage = (function(){var imgNode = document.createElement( 'img' );document.body.appendChild( imgNode );return {setSrc: function( src ){imgNode.src = src; }} 
})();myImage.setSrc( 'http://xxx.jpg' );

我们把网速调至 5KB/s，然后通过 MyImage.setSrc 给该 img 节点设置 src，可以看到，在图片被加载好之前，页面中有一段长长的空白时间。

现在开始引入代理对象 proxyImage，通过这个代理对象，在图片被真正加载好之前，页面中将出现一张占位的菊花图 loading.gif, 来提示用户图片正在加载。
代码如下:

var myImage = (function(){var imgNode = document.createElement( 'img' ); document.body.appendChild( imgNode );return {setSrc: function( src ){imgNode.src = src; }} 
})();
var proxyImage = (function(){ var img = new Image; img.onload = function(){myImage.setSrc( this.src ); }return {setSrc: function( src ){myImage.setSrc( 'http://loading.gif' );img.src = src; }}
})();proxyImage.setSrc( 'http://xxx.jpg' );

现在我们通过 proxyImage 间接地访问 MyImage。proxyImage 控制了客户对 MyImage 的访问，并且在此过程中加入一些额外的操作，比如在真正的图片加载好之前，先把 img 节点的 src 设置为一张 loading 图片。

不用代理的预加载图片函数实现如下:

var MyImage = (function(){var imgNode = document.createElement( 'img' ); document.body.appendChild( imgNode );var img = new Image;img.onload = function(){ imgNode.src = img.src;};return {setSrc: function( src ){imgNode.src = 'http://loading.gif';img.src = src; }} 
})();MyImage.setSrc( 'http://xxx.jpg' );

代理的意义：

为了说明代理的意义，下面我们引入一个面向对象设计的原则——单一职责原则。

单一职责原则指的是，就一个类(通常也包括对象和函数等)而言，应该仅有一个引起它变化的原因。

如果一个对象承担了多项职责，就意味着这个对象将变得巨大，引起它变化的原因能会有多个。面向对象设计鼓励将行为分布到细粒度的对象之中，如果一个对象承担的职责过多，等于把这些职责耦合到了一起，这种耦合会导致脆弱和低内聚的设计。当变化发生时，设计可能会遭到意外的破坏。

职责被定义为“引起变化的原因”。上段代码中的 MyImage 对象除了负责给 img 节点设置 src 外，还要负责预加载图片。我们在处理其中一个职责时，有可能因为其强耦合性影响另外一个职责的实现。

另外，在面向对象的程序设计中，大多数情况下，若违反其他任何原则，同时将违反开放— 封闭原则。

如果我们只是从网络上获取一些体积很小的图片，或者 5 年后的网速快到根本不再需要预加载，我们可能希望把预加载图片的这段代码从 MyImage 对象里删掉。这时候就不得不改动 MyImage 对象了。

实际上，我们需要的只是给 img 节点设置 src，预加载图片只是一个锦上添花的功能。如果能把这个操作放在另一个对象里面，自然是一个非常好的方法。于是代理的作用在这里就体现出来了，代理负责预加载图片，预加载的操作完成之后，把请求重新交给本体 MyImage。

纵观整个程序，我们并没有改变或者增加 MyImage 的接口，但是通过代理对象，实际上给系统添加了新的行为。这是符合开放—封闭原则的。给 img 节点设置 src 和图片预加载这两个功能， 被隔离在两个对象里，它们可以各自变化而不影响对方。何况就算有一天我们不再需要预加载 那么只需要改成请求本体而不是请求代理对象即可。

缓存代理例子——求乘积

var mult = function(){ console.log( '开始计算乘积' ); var a = 1;for ( var i = 0, l = arguments.length; i < l; i++ ){a = a * arguments[i];}console.log( a ); return a;
}
mult( 2, 3 );// 输出:6
mult( 2, 3, 4); // 输出:24//现在加入缓存代理函数:
var proxyMult = (function(){var cache = {};return function(){var args = Array.prototype.join.call( arguments, ',' ); if ( args in cache ){return cache[ args ]; }return cache[ args ] = mult.apply( this, arguments );}
})();
proxyMult( 1, 2, 3, 4 ); // 输出:24
proxyMult( 1, 2, 3, 4 ); // 输出:24

当我们第二次调用 proxyMult( 1, 2, 3, 4 )的时候，本体 mult 函数并没有被计算，proxyMult直接返回了之前缓存好的计算结果。

通过增加缓存代理的方式，mult 函数可以继续专注于自身的职责——计算乘积，缓存的功能是由代理对象实现的。

用高阶函数动态创建代理:

通过传入高阶函数这种更加灵活的方式，可以为各种计算方法创建缓存代理。现在这些计算方法被当作参数传入一个专门用于创建缓存代理的工厂中， 这样一来，我们就可以为乘法、加法、减法等创建缓存代理。
代码如下:

/**************** 计算乘积 *****************/ var mult = function(){var a = 1; for ( var i = 0, l = arguments.length; i < l; i++ ){a = a * arguments[i];}return a; 
};/**************** 计算加和 *****************/
var plus = function(){ var a = 0;for ( var i = 0, l = arguments.length; i < l; i++ ){ a = a+ arguments[i];
}return a; 
};/**************** 创建缓存代理的工厂 *****************/
var createProxyFactory = function( fn ){var cache = {};return function(){var args =Array.prototype.join.call( arguments, ',' );if ( args in cache ){ return cache[ args ];}return cache[ args ] = fn.apply( this, arguments ); }
};var proxyMult = createProxyFactory( mult ), proxyPlus = createProxyFactory( plus );alert ( proxyMult( 1, 2, 3, 4 ) ); // 输出:24alert ( proxyMult( 1, 2, 3, 4 ) ); // 输出:24alert ( proxyPlus( 1, 2, 3, 4 ) );// 输出:10  alert ( proxyPlus( 1, 2, 3, 4 ) );// 输出:10