设计模式：中介者模式（Mediator）

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



中介者模式中的角色： 

1. 抽象中介者（Mediator)：定义了同事对象到中介者对象之间的接口。 

2. 具体中介者（ConcreteMediator)：定义抽象中介者的方法，它需要知道所有的具体同事类，同时需要从具体的同事类那里接收消息，并且向具体的同事类发送信息。 

3. 抽象同事类（Colleague） 

4. 具体同事类（ConcreteColleague）：每个具体同事类都只需要知道自己的行为即可，但是它们都需要认识中介者。

案例1： 

房屋租赁中介就是一个很好的中介模式，租客只知道自己和中介，房东也只知道自己和中介，但是中介必须知道租客和房东。（在我们的生活中处处充斥着“中介者”，比如租房、买房、出过留学、找工作、旅游等可能都需要哪些中介者的帮助。） 

1 抽象中介者

public interface Mediator
{
void contact(String message, Person person);
}

1
2
3
4

2 抽象同事类

public abstract class Person
{
protected String name;
protected Mediator mediator;

Person(String name, Mediator mediator)
{
this.name = name;
this.mediator = mediator;
}
}

1
2
3
4
5
6
7
8
9
10
11

3 具体同事类 

房东：

public class HouseOwner extends Person
{
HouseOwner(String name, Mediator mediator)
{
super(name, mediator);
}

public void contact(String message)
{
mediator.contact(message, this);
}

public void getMessage(String message)
{
System.out.println("HouseOwner : "+name+", Get Message: "+message);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

租客：

public class Tenant extends Person
{
Tenant(String name, Mediator mediator)
{
super(name, mediator);
}

public void contact(String message)
{
mediator.contact(message, this);
}

public void getMessage(String message)
{
System.out.println("Tenant : "+name+", Get Message: "+message);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4 中介

public class MediatorStructure implements Mediator
{
private HouseOwner houseOwner;
private Tenant tenant;

public HouseOwner getHouseOwner()
{
return houseOwner;
}
public void setHouseOwner(HouseOwner houseOwner)
{
this.houseOwner = houseOwner;
}
public Tenant getTenant()
{
return tenant;
}
public void setTenant(Tenant tenant)
{
this.tenant = tenant;
}

@Override
public void contact(String message, Person person)
{
if(person == houseOwner)
{
tenant.getMessage(message);
}
else
{
houseOwner.getMessage(message);
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

5 测试代码

MediatorStructure mediator = new MediatorStructure();

HouseOwner houseOwner = new HouseOwner("qq",mediator);
Tenant tenant = new Tenant("jj",mediator);

mediator.setHouseOwner(houseOwner);
mediator.setTenant(tenant);

tenant.contact("I wanna a house");
houseOwner.contact("I have~");

1
2
3
4
5
6
7
8
9
10

运行结果：

HouseOwner : qq, Get Message: I wanna a house
Tenant : jj, Get Message: I have~

1
2

优缺点 

优点

适当的使用中介者模式可以避免同事类之间的过渡耦合，使得各同事类之间可以相对独立地使用。

减少子类的生成。

可以减少各同事类的设计与实现。

缺点 

1. 由于中介者对象封装了系统中的对象之间的相互关系，导致其变得非常复杂，使得系统维护比较困难。中介者需要知道每个对象和他们之间的交互细节，如果它出问题，将会导致整个系统都会出现问题。所以它比较容易应用也很容易误用。故当系统中出现了“多对多”交互复杂的关系群时，千万别记着使用中介者模式，你首先需要做的就是反思你的系统在设计上是不是合理。再者，在实际工作中，中介者模式也并不多见。

适用场景 

1. 系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 

2. 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

JDK中的中介者模式： 

java.util.Timer 

java.util.concurrent.Executor#execute() 

java.util.concurrent.ExecutorService#submit() 

java.lang.reflect.Method#invoke()

参考资料 

1. 23种设计模式 

2. 细数JDK里的设计模式 

3. 设计模式读书笔记—–中介者模式