java设计模式之中介者模式

中介者模式

面向对象设计鼓励将行为分布到各个对象中, 这种分布可能会导致对象间有许多连接. 在最坏的情况下, 每一个对象都需要知道其他所有对象.

虽然将一个系统分割成许多对象可增强可复用性, 但是对象间相互连接的激增又会降低其可复用性. 大量的连接关系使得一个对象不可能在没有其他对象的协助下工作(系统表现为一个不可分割的整体), 此时再对系统行为进行任何较大改动就十分困难. 因为行为被分布在许多对象中, 结果是不得不定义很多子类以定制系统的行为. 由此我们引入了中介者对象Mediator:

通过中介者对象, 可以将网状结构的系统改造成以中介者为中心的星型结构, 每个具体对象不再与另一个对象直接 * , 而是通过中介者对象从中调停.中介者对象的引入,也使得系统结构不会因新对象的引入造成大量的修改.

中介者模式: 又称调停者模式, 用一个中介者对象(Mediator)来封装一系列对象的交互, 使各对象不需再显示地相互引用, 从而使耦合松散, 而且可以独立地改变他们之间的交互:

(图片来源: 设计模式: 可复用面向对象软件的基础)Tips: 各Colleague只知道Mediator的存在, 并不需要知道其他Colleague是否存在(不然怎么解耦呢), 它只需将消息发送给Mediator, 然后由Mediator转发给其他Colleague(由Mediator存储所有Colleague关系, 也只有Mediator知道有多少/哪些Colleague).

模式实现

联合国转发各国声明, 调停各国关系:
各国向联合国安理会发送和接收消息, 安理会在各国间'适当地'转发请求以实现协作行为:

Colleague

抽象同事类, 定义各同事的公有方法:

/**
* @author jifang
* @since 16/8/28 下午4:22.
*/
public abstract class Country {

protected UnitedNations mediator;

private String name;

public Country(UnitedNations mediator, String name) {
 this.mediator = mediator;
 this.name = name;
}

public String getName() {
 return name;
}

protected abstract void declare(String msg);

protected abstract void receive(String msg);
}

--------------------------------------------------------------------------------

ConcreteColleague

具体同事类:
 •每一个同事类都知道它的中介者对象.
 •每一个同事对象在需与其他同事通信时, 与它的中介者通信. 

class USA extends Country {

public USA(UnitedNations mediator, String name) {
 super(mediator, name);
}

@Override
public void declare(String msg) {
 mediator.declare(this, msg);
}

@Override
public void receive(String msg) {
 System.out.println("美国接收到: [" + msg + "]");
}
}

class Iraq extends Country {

public Iraq(UnitedNations mediator, String name) {
 super(mediator, name);
}

@Override
public void declare(String msg) {
 mediator.declare(this, msg);
}

@Override
public void receive(String msg) {
 System.out.println("伊拉克接收到: [" + msg + "]");
}
}

class China extends Country {

public China(UnitedNations mediator, String name) {
 super(mediator, name);
}

@Override
public void declare(String msg) {
 mediator.declare(this, msg);
}

@Override
public void receive(String msg) {
 System.out.println("中国接收到: [" + msg + "]");
}
}

--------------------------------------------------------------------------------

Mediator

抽象中介者: 定义一个接口用于与各同事对象通信:

public abstract class UnitedNations {

protected List<Country> countries = new LinkedList<>();

public void register(Country country) {
 countries.add(country);
}

public void remove(Country country) {
 countries.remove(country);
}

protected abstract void declare(Country country, String msg);
}

--------------------------------------------------------------------------------

ConcreteMediator

具体中介者:
•了解并维护它的各个同事;
 •通过协调各同事对象实现协作行为(从同事接收消息, 向具体同事发出命令). 

class UnitedNationsSecurityCouncil extends UnitedNations {

/**
 * 安理会在中间作出调停
 *
 * @param country
 * @param msg
 */
@Override
protected void declare(Country country, String msg) {
 for (Country toCountry : countries) {
  if (!toCountry.equals(country)) {
   String name = country.getName();
   toCountry.receive(name + "平和的说: " + msg);
  }
 }
}
}

如果不存在扩展情况, 那么Mediator可与ConcreteMediator合二为一.
 •Client 

public class Client {

@Test
public void client() {
 UnitedNations mediator = new UnitedNationsSecurityCouncil();

Country usa = new USA(mediator, "美国");
 Country china = new China(mediator, "中国");
 Country iraq = new Iraq(mediator, "伊拉克");

mediator.register(usa);
 mediator.register(china);
 mediator.register(iraq);

usa.declare("我要打伊拉克, 谁管我跟谁急!!!");
 System.out.println("----------");
 china.declare("我们强烈谴责!!!");
 System.out.println("----------");
 iraq.declare("来呀, 来互相伤害呀!!!");
}
}

小结

Mediator的出现减少了各Colleague之间的耦合, 使得可以独立改变和复用各Colleague和Mediator, 由于把对象如何协作进行了抽象、将中介作为一个独立的概念并将其封装在一个对象中, 这样关注的焦点就从对象各自本身的行为转移到它们之间的交互上来, 从而可以站在一个更宏观的角度去看待系统.

 •适用性

中介者模式很容易在系统中应用, 也很容易在系统中误用. 当系统出现了“多对多”交互复杂的对象群时, 不要急于使用中介者, 最好首先先反思系统的设计是否是合理. 由于ConcreteMediator控制了集中化, 于是就把交互复杂性变成了中介者的复杂性, 使得中介者变得比任一个ConcreteColleague都复杂. 在下列情况下建议使用中介者模式:

◦一组对象以定义良好但复杂的方式进行通信. 产生的相互依赖关系结构混乱且难以理解.
◦一个对象引用其他很多对象并且直接与这些对象通信, 导致难以复用该对象.
◦想定制一个分布在多个类中的行为, 而又不想生成太多的子类.

•相关模式

◦Facade与中介者的不同之处在于它是对一个对象子系统进行抽象, 从而提供了一个更为方便的接口, 它的协议是单向的, 即Facade对象对这个子系统类提出请求, 但反之则不可. 相反, Mediator提供了各Colleague对象不支持或不能支持的协作行为, 而且协议是多向的.
◦Colleague可使用Observer模式与Mediator通信.