架构师之路--中介者模式

目录

介绍

定义

使用场景

代码实现

---

介绍

     中介者模式也称为调解者模式，它的名字本身就有调停者和调解者的意思，在日常生活中，我们也经常碰到类似的例子，比如A和B有纠纷，双方无法达成一致，那么这时候就需要找一个中间人来评理，或者打官司，这个中间人或者法院就是中介者。或者在我们实际开发工作中，产品、运维、开发、设计、测试都会负责自己职责内的事情，如果有一个需求的修改，各方评估时都是站在自己立场上考虑问题，几方在一起争论不休，根本无法达成一致意见，这样需求修改工作就无法往下进行，这时候由项目经理或者高一级的领导来进行决策，把大家有争议的部分确定下来，这样所有的工作就可以继续往下进行了，这里的项目经理或者高一级的领导也就相当于中介者。

定义

     中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用，从而使它们可以松散耦合，当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用，保证这些作用可以彼此独立的变化，中介者模式将多对多的相互作用转化为一对多的相互作用，中介者模式将对象的行为协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。这里需要我们理解清楚，相互作用的几方肯定是有关联的，中介者模式只是让这几方松耦合，但还是有耦合的，比如上面提到的A和B，产品、运维、开发、设计、测试，我们是让它们多对多的关系变成一对多，由中介者来进行中转，它们之间的内在还是会存在一定耦合的。

使用场景

     当对象之间的交互操作很多且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的行为时，同时涉及修改很多其他对象的行为，可以采用中介者模式，来解决紧耦合的问题，该模式将对象之间的多对多的关系变成一对多的关系，中介者对象将系统从网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高扩展性的目的。实际生活中比如像电脑主板一样，CPU、内存、显卡、声卡、显示器等等设备全部都是通过主板连接起来的，这样它们才能一起相互协作，完成一整套需求。

代码实现

     我们就以平时工作中需求变更为例，伪代码来模拟一下中介者模式的代码实现。首先来模拟一下产品、开发、测试三个角色，他们都是同事Colleague类的子类，代码如下：

public abstract class Colleague {
    protected PM pm;

    public Colleague(PM pm) {
        this.pm = pm;
    }

    protected abstract void handleChange();

}

public class Product extends Colleague {

    public Product(PM pm) {
        super(pm);
    }

    @Override
    protected void handleChange() {
        System.out.println("需求变更");
    }

    public void changeRequirement() {
        pm.change();
    }
}

public class Coder extends Colleague {

    public Coder(PM pm) {
        super(pm);
    }

    @Override
    protected void handleChange() {
        System.out.println("开始实现新的需求变更");
    }
}

public class Tester extends Colleague {

    public Tester(PM pm) {
        super(pm);
    }

    @Override
    protected void handleChange() {
        System.out.println("开始修改测试用例");
    }
}

     当有需求变更时，这三个角色都必须实现handleChange方法，来对变更进行处理，前面我们已经说过，中介者是和他们每一个成员相关联的，所以Colleague中有一个成员变量PM，也就是项目经理，它就是中介者，负责协调各方之间的纠纷。PM的代码如下：

public class PM {
    private Product product;
    private Coder coder;
    private Tester tester;

    public void change() {
        product.handleChange();
        coder.handleChange();
        tester.handleChange();
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    public void setCoder(Coder coder) {
        this.coder = coder;
    }

    public void setTester(Tester tester) {
        this.tester = tester;
    }
}

     它当中会存有Product、Coder、Tester的成员变量，当需求变更时，会将变更的最终结果一一通知它们。就是这么简单的一层，就可以处理非常多的业务逻辑，试想一下，如果我们的工作中有类似复杂的多对多的结构，我们就可以通过中介者模式，将所有关联方集合到这里，所有非单独模块范围内的业务逻辑全部在这里处理完毕，然后调用每个独立模块的处理方法，去处理该模块内部自己的逻辑，这样整个结构就会非常清晰了。

     最后我们来看一下测试代码：

public class Test {

    public static void main() {
        PM pm = new PM();
        Product product = new Product(pm);
        Coder coder = new Coder(pm);
        Tester tester = new Tester(pm);

        pm.setProduct(product);
        pm.setCoder(coder);
        pm.setTester(tester);

        product.changeRequirement();
    }
}