中介模式（Mediator Pattern）

中介者模式（Mediator Pattern）

中介者模式定义：

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

中介者模式的优点：

　　中介者模式的优点是减少了类之间的依赖，使原有一对多的依赖变成了一对一的依赖，同事类只依赖中介者，降低了类之间的耦合。

 

中介者模式的缺点：

　　中介者模式的缺点是中介者会膨胀的很大，而且逻辑复杂，同事类越多，中介者逻辑越复杂。

 

中介者模式的使用场景：

　　中介者模式适合于多个对象之间紧密耦合的情况（类图出现了蜘蛛网结构）。

 

中介者模式的通用类图：

Mediator（抽象中介者角色）：定义了中介者统一的接口，用于各同事角色直接的通信。

ConcreteMediator（具体中介者角色）：协调各同事角色实现协作行为，它依赖各个同事角色。 

Colleague（同事角色）：每一个同事角色都知道中介者角色的存在，而且与其他的同事角色通信的时候，一定会通过中介者角色协调。每个同事类的行为分为两种：第一种是同事角色本身的行为，不与其他同事角色或中介者交互的方法，这种方法叫做自发行为（Self-Method）；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

 

中介模式通用代码：

抽象中介者角色：

public abstract class Mediator
{
    /*中介者依赖各个同事类*/
    private ConcreteColleague1 colleague1 = null;
    private ConcreteColleague2 colleague2 = null;
    
    public Mediator()
    {
        
    }
    
    public ConcreteColleague1 getColleague1()
    {
        return colleague1;
    }

    public void setColleague1(ConcreteColleague1 colleague1)
    {
        this.colleague1 = colleague1;
    }

    public ConcreteColleague2 getColleague2()
    {
        return colleague2;
    }

    public void setColleague2(ConcreteColleague2 colleague2)
    {
        this.colleague2 = colleague2;
    }
    
    /*定义中介者统一接口，用于协调同事角色之间的通信*/
    abstract public void doSomething1();
    abstract public void doSomething2();
}

具体中介者角色：

public class ConcreteMediator extends Mediator
{
    /*中介者对象封装了一系列对象的交互，而且可以独立改变他们之间的交互*/
    @Override
    public void doSomething1()
    {
        super.getColleague1().selfMethod1();
        super.getColleague2().selfMethod1();
    }

    /*中介者对象封装了一系列对象的交互，而且可以独立改变他们之间的交互*/
    @Override
    public void doSomething2()
    {
        super.getColleague1().selfMethod2();
        super.getColleague2().selfMethod2();
    }
}

同事类：

public class ConcreteColleague1
{
    private Mediator mediator = null;
    
    public ConcreteColleague1(Mediator mediator)
    {
        this.mediator = mediator;
    }
    
    /*自发行为1*/
    public void selfMethod1()
    {
        System.out.println("colleague1 selfMethod1 invoke!");
    }
    
    /*自发行为2*/
    public void selfMethod2()
    {
        System.out.println("colleague1 selfMethod2 invoke!");
    }
    
    /*依赖行为*/
    public void depMethod()
    {
        this.mediator.doSomething1();
    }
}

public class ConcreteColleague2
{
    private Mediator mediator = null;
    
    public ConcreteColleague2(Mediator mediator)
    {
        this.mediator = mediator;
    }
    
    public void selfMethod1()
    {
        System.out.println("colleague2 selfMethod1 invoke!");
    }
    
    public void selfMethod2()
    {
        System.out.println("colleague2 selfMethod2 invoke!");
    }
    
    public void depMethod()
    {
        this.mediator.doSomething2();
    }
}

场景类：

public class Client
{
    public static void main(String[] args)
    {
        Mediator mediator = new ConcreteMediator();
        
        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
        
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);
        
        colleague1.depMethod();
        System.out.println("---------------------------------");
        colleague2.depMethod();
    }
}

---

理解"中介者模式"

使用中介者模式会将对象间的复杂一对多的依赖关系简化为一对一的依赖关系：

 

　　没有使用中介者模式之前，对象之间是直接依赖的，对象间的交互方式为直接交互。使用了中介者模式后，每一个对象依赖于中介者对象，需要与其他对象交互时，通过中介者与其他对象交互，是一种间接交互。我们可以再不修改任何同事类的条件下，改变同事类的交互（通过修改中介者）。

中介者模式在实际中的应用：

1. 每一个机场都有"XXX机场调度中心"。这是一个现实版的中介者模式，如果没有这个调度中心，每一架飞机（同事类）在到达机场时，都需要先与其他飞机交互看看有没有飞机与我降落冲突，然后与机场（同事类）交互有没有空闲跑到，最后与后勤部门（同事类）交互看有没有将停机资源准备好等等，这样的情况是难以想象的。

2. MVC框架。Struts2的控制器就是一个典型的中介者。

3. 现实中的各种中介公司。