（36）设计模式之中介者模式

介绍

中介者模式（Mediator），用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

主要内容来自：http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#mediatorpatternjavascript

_6正文

软件开发中，中介者是一个行为设计模式，通过提供一个统一的接口让系统的不同部分进行通信。一般，如果系统有很多子模块需要直接沟通，都要创建一个中央控制点让其各模块通过该中央控制点进行交互。中介者模式可以让这些子模块不需要直接沟通，而达到进行解耦的目的。

打个比方，平时常见的机场交通控制系统，塔台就是中介者，它控制着飞机（子模块）的起飞和降落，因为所有的沟通都是从飞机向塔台汇报来完成的，而不是飞机之前相互沟通。中央控制系统就是该系统的关键，也就是软件设计中扮演的中介者角色。

我们先用伪代码来理解一下：

  1. // 如下代码是伪代码，请不要过分在意代码
  2. // 这里app命名空间就相当于扮演中介者的角色
  3. var app = app || {};
  5. // 通过app中介者来进行Ajax请求
  6. app.sendRequest = function ( options ) {
  7.     return $.ajax($.extend({}, options);
  8. }
  10. // 请求URL以后，展示View
  11. app.populateView = function( url, view ){
  12.   $.when(app.sendRequest({url: url, method: 'GET'})
  13.      .then(function(){
  14.          //显示内容
  15.      });
  16. }
  18. // 清空内容
  19. app.resetView = function( view ){
  20.    view.html('');
  21. }

在JavaScript里，中介者非常常见，相当于观察者模式上的消息Bus，只不过不像观察者那样通过调用pub/sub的形式来实现，而是通过中介者统一来管理，让我们在观察者的基础上来给出一个例子：

  1. var mediator = (function () {
  2.     // 订阅一个事件，并且提供一个事件触发以后的回调函数
  3.     var subscribe = function (channel, fn) {
  4.         if (!mediator.channels[channel]) mediator.channels[channel] = [];
  5.         mediator.channels[channel].push({ context: this, callback: fn });
  6.         return this;
  7.     },
  9.     // 广播事件
  10.     publish = function (channel) {
  11.         if (!mediator.channels[channel]) return false;
  12.         var args = Array.prototype.slice.call(arguments, 1);
  13.         for (var i = 0, l = mediator.channels[channel].length; i < l; i++) {
  14.             var subscription = mediator.channels[channel][i];
  15.             subscription.callback.apply(subscription.context, args);
  16.         }
  17.         return this;
  18.     };
  20.     return {
  21.         channels: {},
  22.         publish: publish,
  23.         subscribe: subscribe,
  24.         installTo: function (obj) {
  25.             obj.subscribe = subscribe;
  26.             obj.publish = publish;
  27.         }
  28.     };
  30. } ());

调用代码，相对就简单了：

  1. (function (Mediator) {
  3.     function initialize() {
  5.         // 默认值
  6.         mediator.name = "dudu";
  8.         // 订阅一个事件nameChange
  9.         // 回调函数显示修改前后的信息
  10.         mediator.subscribe('nameChange', function (arg) {
  11.             console.log(this.name);
  12.             this.name = arg;
  13.             console.log(this.name);
  14.         });
  15.     }
  17.     function updateName() {
  18.         // 广播触发事件，参数为新数据
  19.         mediator.publish('nameChange', 'tom'); // dudu, tom
  20.     }
  22.     initialize(); // 初始化
  23.     updateName(); // 调用
  25. })(mediator);

_105中介者和观察者

到这里，大家可能迷糊了，中介者和观察者貌似差不多，有什么不同呢？其实是有点类似，但是我们来看看具体的描述：

观察者模式，没有封装约束的单个对象，相反，观察者Observer和具体类Subject是一起配合来维护约束的，沟通是通过多个观察者和多个具体类来交互的：每个具体类通常包含多个观察者，而有时候具体类里的一个观察者也是另一个观察者的具体类。

而中介者模式所做的不是简单的分发，却是扮演着维护这些约束的职责。

_112中介者和外观模式

很多人可能也比较迷糊中介者和外观模式的区别，他们都是对现有各模块进行抽象，但有一些微妙的区别。

中介者所做的是在模块之间进行通信，是多向的，但外观模式只是为某一个模块或系统定义简单的接口而不添加额外的功能。系统中的其它模块和外观模式这个概念没有直接联系，可以认为是单向性。

_118完整的例子

再给出一个完整的例子：

  1. <!doctype html>
  2. <html lang="en">
  3. <head>
  4.     <title>JavaScript Patterns</title>
  5.     <meta charset="utf-8">
  6. </head>
  7. <body>
  8. <div id="results"></div>
  9.     <script>
  10.         function Player(name) {
  11.             this.points = 0;
  12.             this.name = name;
  13.         }
  14.         Player.prototype.play = function () {
  15.             this.points += 1;
  16.             mediator.played();
  17.         };
  18.         var scoreboard = {
  20.             // 显示内容的容器
  21.             element: document.getElementById('results'),
  23.             // 更新分数显示
  24.             update: function (score) {
  25.                 var i, msg = '';
  26.                 for (i in score) {
  27.                     if (score.hasOwnProperty(i)) {
  28.                         msg += '<p><strong>' + i + '<\/strong>: ';
  29.                         msg += score[i];
  30.                         msg += '<\/p>';
  31.                     }
  32.                 }
  33.                 this.element.innerHTML = msg;
  34.             }
  35.         };
  37.         var mediator = {
  39.             // 所有的player
  40.             players: {},
  42.             // 初始化
  43.             setup: function () {
  44.                 var players = this.players;
  45.                 players.home = new Player('Home');
  46.                 players.guest = new Player('Guest');
  47.             },
  49.             // play以后，更新分数
  50.             played: function () {
  51.                 var players = this.players,
  52.                     score = {
  53.                         Home: players.home.points,
  54.                         Guest: players.guest.points
  55.                     };
  57.                 scoreboard.update(score);
  58.             },
  60.             // 处理用户按键交互
  61.             keypress: function (e) {
  62.                 e = e || window.event; // IE
  63.                 if (e.which === 49) { // 数字键 "1"
  64.                     mediator.players.home.play();
  65.                     return;
  66.                 }
  67.                 if (e.which === 48) { // 数字键 "0"
  68.                     mediator.players.guest.play();
  69.                     return;
  70.                 }
  71.             }
  72.         };
  74.         // go!
  75.         mediator.setup();
  76.         window.onkeypress = mediator.keypress;
  78.         // 30秒以后结束
  79.         setTimeout(function () {
  80.             window.onkeypress = null;
  81.             console.log('Game over!');
  82.         }, 30000);
  83.     </script>
  84. </body>
  85. </html>

_210总结

中介者模式一般应用于一组对象已定义良好但是以复杂的方式进行通信的场合，一般情况下，中介者模式很容易在系统中使用，但也容易在系统里误用，当系统出现了多对多交互复杂的对象群时，先不要急于使用中介者模式，而是要思考一下是不是系统设计有问题。

另外，由于中介者模式把交互复杂性变成了中介者本身的复杂性，所以说中介者对象会比其它任何对象都复杂。