代理模式 - Design Patterns

Search…

代理模式

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

模式动机
在某些情况下，一个客户不想或者不能直接引用一个对象，此时可以通过一个称之为「代理」的第三者来实现间接引用。代理对象可以在客户端和目标对象之间起到中介作用，并且可以通过代理对象过滤掉客户不能看到的内容或者增强提供的服务
虚拟代理
把一些开销很大的对象，延迟到真正需要它的时候才去创建
例如图片的预加载技术，如果直接给 img 设置 src 属性，有时会因为图片太大或者网络不佳造成很长时间的空白，常见的做法是先用一张 loading 图占位，待真正的图片加载好之后再做替换。
首先创建一个普通的图像类，暴露一个 setSrc 接口用来设置 img 标签的 src 属性
1
const myImage = (function() {
2
  const imgNode = document.createElement("img")
3
  document.body.appendChild(imgNode)
4
​
5
  return {
6
    setSrc: function(src) {
7
      imgNode.src = src
8
    }
9
  }
10
})()
Copied!
引入代理对象 proxyImg ，在图片被真正加载好之前，页面中用本地图片来占位
1
const proxyImage = (function() {
2
  // 创建一个 img 用来下载图片到缓存中
3
  const img = new Image()
4
  // 图片加载完成调用此方法
5
  img.onload = function() {
6
    myImage.setSrc(this.src)
7
  }
8
  return {
9
    setSrc: function(src) {
10
      // 立即用本地图片代替
11
      myImage.setSrc("local_pic_url")
12
      img.src = src // img 开始加载
13
    }
14
  }
15
})()
16
​
17
proxyImage.setSrc( 'real_pic_url' )
Copied!
我们通过 proxyImg 间接的访问 myImage ，并在访问 myImage 过程中加入了额外的操作，比如在真正的图片加载好之前，将 myImage 的 src 先设置为本地的图片，待图片加载好之后再做替换。
缓存代理
缓存代理可以为一个开销很大的运算提供暂时的存储，在下次运算时，如果传递进来的参数跟之前完全一致，则可以直接返回之前的运算结果
这里以一个简单的乘积计算作为例子，我们假装他非常耗时
1
const mult = function() {
2
  let a = 1
3
  for (let i = 1; i < arguments.length; i++) {
4
    a *= arguments[i]
5
  }
6
  return a
7
}
Copied!
下面我们加入缓存代理，输入相同参数时不需要再次计算
1
const proxyMult = (function() {
2
  const cache = {}
3
  return function() {
4
    const args = Array.prototype.join.call(arguments, ",")
5
    if (args in cache) {
6
      return cache[args]
7
    }
8
    return (cache[args] = mult.apply(this, arguments))
9
  }
10
})()
11
​
12
proxyMult( 1, 2, 3, 4 ); // 输出:24
13
proxyMult( 1, 2, 3, 4 ); // 输出:24 此时并不需要再次计算
Copied!
用高阶函数动态创建代理
如上所示，如果我们要再写一个加法操作的代理时，是还需要再为其编写一个 proxyAdd 方法的，这样显然是不符合我们的开闭原则的。
假设现有如下的加法和乘法的耗时操作
1
// 乘法
2
const mult = function() {
3
  let a = 1
4
  for (let i = 1; i < arguments.length; i++) {
5
    a *= arguments[i]
6
  }
7
  return a
8
}
9
​
10
// 加法
11
const add = function() {
12
  let a = 1
13
  for (let i = 1; i < arguments.length; i++) {
14
    a += arguments[i]
15
  }
16
  return a
17
}
Copied!
创建缓存代理的工厂
1
const createProxyFactory = function(fn) {
2
  const cache = [] // 用于缓存参数及结果
3
  return function() {
4
    // 当然这里对参数传递的顺序也需要相同，此处只是举个例子
5
    const argString = Array.prototype.join.call(arguments, '')
6
    // 如果参数之前传输过
7
    if(argString in cache) {
8
      return cache[argString]
9
    }
10
    return cache[argString] = fn.apply(this, arguments)
11
  }
12
}
13
​
14
const proxyPlus = createProxyFactory( add )
15
proxyPlus(1,2,3,4) // 10
Copied!
小结
代理模式包括许多小分类，在 JavaScript 开发中最常用的是「虚拟代理」和「缓存代理」。虽然代理模式非常有用，但我们在编写业务代码的时候，往往不需要去预先猜测是否需要使用代理模式。 
当真正发现不方便直接访问某个对象的时候，再编写代理也不迟
​

策略模式

迭代器模式

Last modified 2yr ago

Copy link

Contents