设计模式之旅15--中介者模式

1. 定义

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

中介者模式

2. 使用场景

• 当对象之间的交互很多而且每个对象的行为操作都依赖彼此时，为了防止在修改一个对象的行为同时涉及修改很多其他对象的行为。
• 出现了网状结构导致出现紧密耦合的时候，中介者模式可以将多对多变成一对多的关系，实现星形结构，降低系统复杂性，提高系统扩展性。
• Android中Activity就充当了中介者的角色。
• MVC、MVP等框架。

3. 实现

下面以一个完整的买房子的过程为例子，介绍中介者模式的简单实现。

中介者及其实现：

/**
 * 中介者：协调各个同事角色，实现协作
 */
public abstract class Mediator {

    protected ConcreteColleague1 mColleague1;
    protected ConcreteColleague2 mColleague2;

    public abstract void doSomething1();

    public abstract void doSomething2();

    public ConcreteColleague1 getColleague1() {
        return mColleague1;
    }

    public void setColleague1(ConcreteColleague1 colleague1) {
        mColleague1 = colleague1;
    }

    public ConcreteColleague2 getColleague2() {
        return mColleague2;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
        mColleague2 = colleague2;
    }
}

/**
 * 例子：房产中介
 */
public class ConcreteMediator extends Mediator {

    @Override
    public void doSomething1() {
        System.out.println("房产中介：帮你找到卖家");
        //通知卖家整理好房子
        this.mColleague2.selfMethod2();
        this.mColleague2.depMethod2();
    }

    @Override
    public void doSomething2() {
        System.out.println("房产中介：帮你找到买家");
        this.mColleague1.selfMethod1();
    }

}

同事类及其实现：

/**
 * 同事类
 */
public abstract class Colleague {

    protected Mediator mMediator;

    public Colleague(Mediator mediator) {
        mMediator = mediator;
    }
}

/**
 * 买家
 */
public class ConcreteColleague1 extends Colleague {

    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    /**
     * 自发行为：同事本身的行为，例如改变对象自身的状态，处理自己的行为
     */
    public void selfMethod1() {
        System.out.println("买家：付款，购买房子");
    }

    /**
     * 依赖行为：自己不能完成的业务，必须依赖中介者才能完成的行为
     */
    public void depMethod1() {
        System.out.println("买家：嘿，房产中介，我要买房");
        //通知中介者，我要买房
        this.mMediator.doSomething1();
    }
}

/**
 * 卖家
 */
public class ConcreteColleague2 extends Colleague {

    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void selfMethod2() {
        System.out.println("卖家：嘿，房子整理中……房子整理好了");
    }

    public void depMethod2() {
        System.out.println("卖家：嘿，房产中介，帮我告诉买家，房子整理好了，房子可以出售");
        //通知中介者，房子可以出售
        this.mMediator.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.depMethod1();
    }

}

运行结果：

买家：嘿，房产中介，我要买房
房产中介：帮你找到卖家
卖家：嘿，房子整理中……房子整理好了
卖家：嘿，房产中介，帮我告诉买家，房子整理好了，房子可以出售
房产中介：帮你找到买家
买家：付款，购买房子

4. 优点

• 中介者模式的优点就是减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖。同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。
• 降低系统复杂度，提高系统的可扩展性。

5. 缺点

• 中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。
• 中介者模式容易被误用。如果几个类之间的依赖关系并不复杂，使用中介者模式反而会使得逻辑结构变复杂。