第14章 中介者模式
中介者模式的作用就是解除对象与对象之间的紧耦合关系。增加一个中介者对象后，所有的相关对象通过中介者对象来通信，而不是互相引用，所以当一个对象发生改变时，只需要通知中介者对象即可。中介者使各对象之间耦合松散，而且可以独立地改变他们之间的交互。中介者模式使网状的多对多关系变成了相对简单的一对多关系。
如上图A发生改变，则需要同时通知跟A发生引用关系的BCDEF这4个对象，而使用中介者模式之后，A发生改变时则只需要通知这个中介者对象即可
14.1 现实中的中介者
1. 机场指挥塔
2. 博彩公司
14.2 中介者模式的例子----泡泡游戏
大家可能都还记得泡泡堂游戏，作者曾经写过一个，在游戏之初只支持两个玩家同时进行对战。
先定义一个玩家构造函数，它有3个简单的原型方法Play.prototype.win、Play.prototype.lose、Play.prototype.die
因为玩家数目是2个，所以当其中一个玩家死亡的时候游戏便结束，同时通知它的对手胜利。
function Player(name){
this.name= name;
this.enemy=null;
}
Player.prototype.win=function(){
console.log(this.name+'won');
}
Player.prototype.lose=function(){
console.log(this.name+'lost');
}
Player.prototype.die=function(){
this.lose();
this.enemy.win();
}
接下来创建2个玩家
var player1 = new Player(‘皮蛋’);
var player2 = new Player(‘小乖’);给玩家相互设置敌人
player1.enemy = player2;
player2.enemy = player1;当玩家player1被泡泡炸死的时候，只需要调用这一句代码便完成了一局游戏
player1.die();后来觉得2人玩没有意思，真正的泡泡堂游戏至多可以有8个玩家，并分成红蓝两队进行游戏。
14.2.1 为游戏增加队伍
现在我们改进一下游戏。因为玩家数量变多，用下面的方式来设置队友和敌人无疑很低效。
player1.partners = [player1, player2, player3,player4];
player1.enemies = [player5, player6, player7,player8];
.
.
.
player5.partners = [player5, player,6, player7,player8];
player5.enemies = [player1, player2, player3,player4];所以我们定义一个数组players来保存所有的玩家，在创建玩家之后，循环players来给每个玩家设置队友和敌人。
var players = [];
再改写构造函数Player，使每个玩家对象都增加一些属性，分别是队友列表、敌人列表、玩家当前状态、角色名字以及玩家所在的队伍颜色。
function Player(name,teamColor){
this.partners = [];
this.enemies = [];
this.state = 'live';
this.name = name;
this.teamColor = teamColor;
}玩家胜利和失败之后的展现依然很简单，只是在每个玩家屏幕上简单地弹出提示：
Player.prototype.win = function(){
console.log(‘winner:’+this.name);
}
Player.prototype.lose = function(){
console.log(‘loser:’+this.name);
}玩家死亡的方法要变得稍微复杂一点，我们需要在每个玩家死亡的时候，都遍历其他队友的生存状况：
Player.prototye.die= function(){
var all_dead = true;
this.state = ‘dead’;
for(var i=0,partner;partner =this.partners[i++];){
if(partner.state!==’dead’){
all_dead = false;
break;
}
}
if(all_dead===true){
this.lose();
for(var i=0,partner;partner = this.partners[i++];){
partner.lose();
}
for(var i=0,enemy;emeny = this.enemies[i++];){
enemy.win();
}
}
}最后定义一个工厂来创建玩家
var playerFactory=function(name,teamColor){
var newPlayer=newPlayer(name,teamColor);
for(vari=0,player;player= players[i++];){
if(player.teamColor ===newPlayer.teamColor){
player.partners.push(newPlayer);
newPlayer.partners.push(player);
}else{
player.enemies.push(newPlayer);
newPlayer.enemies.push(newPlayer);
}
}
players.push(newPlayer);
return newPlayer;
}现在来感受一下，用这段代码创建8个玩家：
//红队
var plaery1 =playerFactory(‘皮蛋’,’red’),
plaery2 =playerFactory(‘小乖’,’red’),
plaery3 = playerFactory(‘宝宝’,’red’),
plaery4 =playerFactory(‘小强’,’red’)//蓝队
var plaery5 =playerFactory(‘黑妞’,’blue’),
plaery6 =playerFactory(‘葱头’,’blue’),
plaery7 =playerFactory(‘胖墩’,’blue’),
plaery8 =playerFactory(‘海盗’,’blue’);测试让红队全部死忘
player1.die();
player2.die();
player4.die();
player3.die();14.2.2 玩家增多带来的困扰
现在我们已经可以随意地为游戏增加玩家或者队伍，但问题是，每个玩家和其他玩家都是紧耦合在一起的。在此段代码中，每个玩家对象都有两个属性，this.partners和this.enemies，用来保存其他玩家对象的引用。当每个对象的状态发生改变，比如角色移动、吃到道具或者死亡时，都要显式地遍历通知其他对象。
在这个例子中只创建了8个玩家，或许没有对你产生足够的困扰，而如果在一个大型网络游戏中，画面里有成百上千的玩家……
14.2.3 用中介者模式改造泡泡堂游戏
首先还是来定义Player构造函数和player对象的原型方法，在player对象的这些原型方法中，不再负责具体的执行逻辑，而是把操作转交给中介者对象，我们把中介者对象命名为playerDirector
function Player(name,teamColor){
this.name= name;
this.teamColor= teamColor;
this.state='alive';//玩家生存状态
}
Player.prototype.win=function(){
console.log(this.name+"won");
}
Player.prototype.lose=function(){
console.log(this.name+"lost");
/*******玩家死亡*******/
Player.prototype.die=function(){
this.state='dead';
playerDirector.ReceiveMessage('playerDead',this);//给中介者发送消息，玩家死亡
}
Player.prototype.remove=function(){
playerDirector.ReceiveMessage('removePlayer',this);
}
Player.prototype.changeTeam=function(color){
playerDirector.ReceiveMessage('changeTeam',this, color);
}
再继续改写之前创建玩家对象的工厂函数，可以看到，因为工厂函数里不需要给创建玩家对象设置队友和敌人，这个工厂函数几乎失去了工厂的意义：
var playerFactory=function(name,teamColor){
var newPlayer=newPlayer(name,teamColor);
playerDirector.ReceiveMessage('addPlayer',newPlayer);
return newPlayer
}
最后我们需要实现这个中介者playerDirector对象，一般有以下两种方式：
o 利用发布—订阅模式。将playerDirector实现为订阅者，各player作为发布者，一旦player的状态发生改变，便推送消息给playerDirector，playerDirector处理消息后反馈发送给其他player
o 在playerDirector中开放一些接收消息的接口，各player可以直接调用接口来给playerDirector发送消息，player只需要传递一个参数给playerDirector，这个参数的目的是使playerDirector可以识别发送者。同样playerDirector接收到消息之后会将处理结果反馈给其他player.
我们采用第二种方式：
var playerDirector= (function() {
var players= {},//保存所有玩家
operations = {};//中介者可以执行的操作
//新增玩家
operations.addPlayer=function(player) {
var teamColor= player.teamColor;
player[teamColor] = players[teamColor] || [];
player[teamColor].push(player);
}
//移除玩家
operations.removePlayer=function(player) {
var teamColor= player.teamColor;
var teamPlayers=players[teamColor] || [];//该队所有成员
for (vari=teamPlayers.length-1; i >= 0;i--) {
if (teamPlayers[i] === player) {
teamPlayers.splice(i,1);
}
}
}
//玩家换队
operations.changeTeam=function(player, newTeamColor) {
operations.removePlayer(player);
player.teamColor = newTeamColor;
operations.addPlayer(player);
}
//玩家死亡
operations.playerDead=function() {
var teamColor=players.teamColor;
var teamPlayers=players[teamColor];
var all_dead=true;
for (vari=0,player;player= teamPlayers[i++];) {
if (player.state!=='dead') {
all_dead = false;
break;
}
}
if (all_dead===true) {
for (vari=0,player;player= teamPlayers[i++];) {
player.lose();
}
for (varcolorinplayers) {
if (color!=teamColor) {
var teamPlayers=players[color];
for (vari=0,player;player= teamPlayers[i++];) {
player.win();
}
}
}
}
}
var ReceiveMessage = function () {
var message= Array.prototype.shift.call(arguments);
operations[message].apply(this,arguments);
}
return {
ReceiveMessage: ReceiveMessage
}
})();
可以看到，除了中介者本身，没有一个玩家知道其他任何玩家的存在，玩家与玩家之间的耦合关系已经完全解除，某个玩家的任何操作都不需要通知其它玩家，而只需要给中介者发送一个消息，中介者处理完消息之后会把处理结果反馈给其他的玩家对象。
14.3 中介者模式的例子—购买商品
我看懂了就不往这记啦。略，感谢去看看作者的书吧
1276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
