中介者模式的使用

一、模式介绍

中介模式旨在用一个中介来封装一系列对象的交互，使得各个对象不需要显式地发生交互，从而达到各个对象松耦合的目的。如果没有中介模式，每个同事对象可能都需要与其它同事对象发生耦合，显示地相互引用，就会造成笛卡尔积，最终导致代码难以扩展和维护，违反了开闭原则。

在使用中介模式之后，原来笛卡尔积的网状模式就可以演化为以中介为中心的星型模式，所有同事对象只和中介耦合，想要调用别的同事的服务时，委托给中介进行。如此降低了整个系统的耦合度，方便扩展新的同事对象。中介模式一般包含如下几个角色：

• 抽象中介者，保持所有同事对象的引用，和定义调用这些同事对象的行为；
• 具体中介者，实现调用和协调这些同事对象的具体行为；
• 具体同事类，负责实现自己的业务逻辑供中介使用，同时转发自己需要的服务交给中介者去找其它同事对象实现；

中介者模式的通用实现代码如下：

/**
 * 抽象中介者
 */
@Data
public abstract class Mediator {
    /**
     * 保持对所有同事的引用，帮他们处理具体业务
     */
    protected WorkerOne workerOne;
    protected WorkerTwo workerTwo;

    public abstract void doWorkOne();

    public abstract void doWorkTwo();
}

public class ConcreteMediator extends Mediator{
    @Override
    public void doWorkOne() {
        workerOne.workerOneTask();
    }

    @Override
    public void doWorkTwo() {
        workerTwo.workerTwoTask();
    }
}

@Slf4j
public class WorkerOne {
    /**
     * 保持对中介者的引用，所有操作都交给中介进行
     */
    private Mediator mediator;

    public WorkerOne(Mediator mediator){
        this.mediator = mediator;
        this.mediator.setWorkerOne(this);
    }

    public void workerOneTask(){
        log.info("WorkerOne执行任务~！");
    }

    public void needWorkerTwo(){
        this.mediator.doWorkTwo();
    }
}

@Slf4j
public class WorkerTwo {
    /**
     * 保持对中介者的引用，所有操作都交给中介进行
     */
    private Mediator mediator;

    public WorkerTwo(Mediator mediator){
        this.mediator = mediator;
        this.mediator.setWorkerTwo(this);
    }

    public void workerTwoTask(){
        log.info("WorkerTwo执行任务~！");
    }

    public void needWorkerOne(){
        this.mediator.doWorkOne();
    }
}

public class Main {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        WorkerOne one = new WorkerOne(mediator);
        WorkerTwo two = new WorkerTwo(mediator);

        // one借助中介mediator让two工作
        one.needWorkerTwo();
        // two借助中介mediator让one工作
        two.needWorkerOne();
    }
}

二、使用场景

• JDK中Timer类的实现；

三、模式总结

3.1 优点

• 减少了类之间的依赖耦合，将多对多的关系转化为一对多的关系；
• 类之间负责各司其职即可，无需知道其它类的细节，符合迪米特法则；

3.2 缺点

• 同事类较多时，中介者就会变得非常臃肿，复杂和难以维护；