中介者模式

[Miracle]

中介者模式

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

中介者模式是迎合迪米特法则（最少知识原则）的一种实现，是指一个对象应该尽可能少地了解另外的对象

优点：

减少类间的依赖与耦合

缺点：

中介者的逻辑会很复杂

实现

Java

/**
 * 抽象中介者
 **/
public abstract class Mediator {
    protected ConcreteColleague concreteColleague;

    public ConcreteColleague getConcreteColleague() {
        return concreteColleague;
    }

    public void setConcreteColleague(ConcreteColleague concreteColleague) {
        this.concreteColleague = concreteColleague;
    }

    public abstract void doSomething1();
}

/**
 * 具体中介者
 **/
public class ConcreteMediator extends Mediator{
    @Override
    public void doSomething1() {
        super.concreteColleague.selfMethod1();
    }
}

/**
 * 抽象同事类
 **/
public class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator _mediator) {
        this.mediator = _mediator;
    }
}

/**
 * 具体同事类
 **/
public class ConcreteColleague extends Colleague{
    public ConcreteColleague(Mediator _mediator) {
        super(_mediator);
    }

    // 自有方法
    public void selfMethod1() {

    }

    // 依赖方法
    public void depMethod1() {
        super.mediator.doSomething1();
    }
}

public class Client {
    public static void main(String[] args) {
        Mediator concreteMediator = new ConcreteMediator();
        Colleague concreteColleague = new ConcreteColleague(concreteMediator);

        concreteColleague.mediator.doSomething1();
    }
}

JavaScript

function Player(name, teamColor) {
  this.name = name;
  this.teamColor = teamColor;
  this.state = 'alive';
};

Player.prototype.win = function () {
}

Player.prototype.lose = function () {
}

Player.prototype.die = function () {
  this.state = 'dead';
  playerDirector.reciveMessage('playerDead', this);
}

Player.prototype.remove = function () {
  playerDirector.reciveMessage('removePlayer', this);
}

Player.prototype.changeTeam = function (color) {
  playerDirector.reciveMessage('changeTeam', this, color);
}

var playerFactory = function (name, teamColor) {
  var newPlayer = new Player(name, teamColor);
  playerDirector.reciveMessage('addPlayer', newPlayer);

  return newPlayer;
}

var playerDirector = (function () {
  var players = {},
    operations = {};

  operations.addPlayer = function (player) {
    var teamColor = player.teamColor;
    players[teamColor] = players[teamColor] || [];
    players[teamColor].push(player);
  }

  operations.removePlayer = function () {
    // todo
  }

  operations.changeTeam = function (player, newTeamColor) {
    operations.removePlayer(player);
    player.teamColor = newTeamColor;
    operations.addPlayer(player);
  }

  operations.playerDead = function (player) {
    // todo
  }

  var reciveMessage = function () {
    var message = Array.prototype.shift.call(arguments);
    operations[message].apply(this, arguments);
  }

  return {
    reciveMessage
  }
})();