初识设计模式 - 中介模式

时间：2022-11-09 09:05:26

简介

中介设计模式（Mediator Design Pattern）定义了一个单独的（中介）对象，来封装一组对象之间的交互。

如果对象之间存在大量的相互关联和调用，若有一个对象发生变化，则需要跟踪和该对象的其他所有对象，并进行适当处理。

而中介模式将这些对象之间的交互委派给中介对象交互，来避免对象之间直接交互，使其耦合松散。

典型实现

首先，定义一个抽象中介者接口，该接口用于与各对象之间进行通信。其代码示例如下：

public abstract class Mediator {
    // 维持所有同事对象的引用
    protected ArrayList<Colleague> colleagues;

    // 注册方法，用于增加同事对象
    public void register(Colleague colleague) {
        colleagues.add(colleague);
    }

    // 声明抽象的业务方法
    public abstract void operation();
}

对于具体的中介者对象，主要是实现自己的业务方法，封装同事之间的调用。其代码示例如下：

public class ConcreteMediator extends Mediator {
    @Override
    public void operation() {
        // 通过中介者调用同事类的方法
        this.colleagues.get(0).method1();
    }
}

然后，需要定义一个抽象的同事类，其维持了一个抽象中介者的引用，用于调用中介者的方法。其代码示例如下：

public abstract class Colleague {
    // 维持一个抽象中介者的引用
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    // 声明自身方法，处理自己的行为
    public abstract void method1();

    // 定义依赖方法，与中介者通信
    public void method2() {
        mediator.operation();
    }
}

具体的同事类也比较简单，只需要继承自抽象同事类，然后定义好自己的行为即可。

总结

优点

中介模式的主要优点如下：

  • 中介模式将一对多的关系简化成了一对一的关系，降低了类的复杂度，简化了对象之间的交互
  • 将各同事对象解耦，增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”
  • 中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使得各个同事类可被重用，无须对同事类进行扩展

缺点

中介模式的主要缺点如下：

  • 具体的中介者类中包含了大量同事之间的交互逻辑，可能会导致具体中介者类非常复杂

适用场景

中介模式的适用场景如下：

  • 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解
  • 一个对象由于引用了许多其他对象并且直接和这些对象通信，导致难以复用该对象
  • 想通过一个中间类来封装多个类中的行为，而又不想生成太多子类

源码

在 JDK 中 java.util.Timer 就使用到了中介模式。如下是其源码部分：

public class Timer {
    private final TaskQueue queue = new TaskQueue();

    private void sched(TimerTask task, long time, long period) {
        if (time < 0)
            throw new IllegalArgumentException("Illegal execution time.");

        if (Math.abs(period) > (Long.MAX_VALUE >> 1))
            period >>= 1;

        synchronized(queue) {
            if (!thread.newTasksMayBeScheduled)
                throw new IllegalStateException("Timer already cancelled.");

            synchronized(task.lock) {
                if (task.state != TimerTask.VIRGIN)
                    throw new IllegalStateException(
                        "Task already scheduled or cancelled");
                task.nextExecutionTime = time;
                task.period = period;
                task.state = TimerTask.SCHEDULED;
            }

            queue.add(task);
            if (queue.getMin() == task)
                queue.notify();
        }
    }
}
标签：

相关文章