中介者模式（行为型）

  中介这个词在我们听的不要太多了，印象最深刻的莫过于房产中介了，你看见一个穿着西装打着领带的人迈着疾快的步伐向你走来，别担心，他只是想问问你买不买房。
  在使用手机远距离通话时，手机也可以看做是中介：一个人在哈尔滨，一个人在三亚，他们要交流靠喊是不可能的，只有通过手机来进行，在哈尔滨的把要说的话告诉手机，手机通过无线传输将信息传到在三亚的手机上，在三亚的人就可以听到在哈尔滨的说的话了。

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

结构：

• 抽象中介者：定义了同事对象到中介者对象的接口
• 具体中介者：中介者具体实现，从具体的同事对象接收消息，向具体的同事对象发出命令
• 抽象同事：定义了中介者对象的接口，只知道中介者而不知道其他的同事对象
• 具体同事：只知道本身在小范围内的行为，而不知道它在大范围内的目的

适用场景：

• 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解
• 一个对象由于引用了其他对象并且直接和这些对象通信，导致难以复用该对象
• 行通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果需要改变行为则可以增加新的具体中介者类

UML类图：

下面就是中介者模式的编码实现，这里以租房子为例子：

Colleague：

public abstract class Person {
    String name;
    Mediator mediator;
    public Person(String name,Mediator mediator){
        this.name = name;
        this.mediator = mediator;
    }
    public abstract void constact(String message);
    public abstract void getMessage(String message);
}

//房东
public class HouseOwner extends Person{
    public HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }
    @Override
    public void getMessage(String message) {
        System.out.println("房主"+this.name+"获得消息："+message);
    }
    @Override
    public void constact(String message) {
        mediator.constact(message, this);
    }
}

//租客
public class Tenant extends Person{
    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }
    @Override
    public void getMessage(String message) {
        System.out.println("租客"+this.name+"获得消息："+message);
    }
    @Override
    public void constact(String message) {
        mediator.constact(message, this);
    }
}

Mediator：

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

public class MediatorStructure implements Mediator{
    Person houseOwner;
    Person tenant;
    public Person getHouseOwner() {
        return houseOwner;
    }
    public void setHouseOwner(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }
    public Person getTenant() {
        return tenant;
    }
    public void setTenant(Tenant tenant) {
        this.tenant = tenant;
    }
    @Override
    public void constact(String message, Person person) {
        person.getMessage(message);
    }
}

Test：

public class Test {
    public static void main(String[] args){
        Mediator media = new MediatorStructure();
        Person houseOwner = new HouseOwner("张三", media);
        Person tenant = new Tenant("李四",media);
        tenant.constact("要租一个单间，不要隔断房，30平，带独立卫生间，有阳台，租金1500以内");
        houseOwner.constact("有这样的，但是要1800");
        tenant.constact("这个鬼地方这种房间也要1800，太贵了，我再看看");
        houseOwner.constact("那1600，不能再少了");
        tenant.constact("太贵了，不要");
        houseOwner.constact("好好好，1500给你了");
        tenant.constact("好，那我租了");
        houseOwner.constact("那明天来签合同吧");
    }
}

总结：在面向对象的编程语言里，一个类必然会与其他类产生依赖关系，如果这种依赖关系如网状般错综复杂，那么必然会影响我们的代码逻辑以及执行效率，适当的使用中介则模式可以对这种依赖关系进行解耦使得逻辑结构清晰；但是如果几个类间的依赖关系不复杂，使用中介者模式反而会使得原本不复杂的逻辑结构变得复杂；在使用中介者模式时要多方考虑，权衡利弊。

---

参考：《Android源码设计模式与实战》
   http://www.cnblogs.com/chenssy/p/3348520.html