中介者模式 Mediator Pattern

一、模式介绍

1.1、定义

中介模式又叫调停模式，是迪米特法则的典型应用。它定义了一个单独的（中介）对象，来封装一组对象之间的交互。将这组对象之间的交互委派给与中介对象交互，来避免对象之间的直接交互。

1.2、优点

1. 类之间各司其职，符合迪米特法则
2. 降低了对象之间的耦合性，使得对象易于独立地被复用
3. 将对象之间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展

1.3、缺点

中介模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

二、结构与实现

2.1、结构

1. 抽象中介者角色（Mediator）：中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法
2. 具体中介者角色（ConcreteMediator）：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色
3. 抽象同事类角色（Colleague）：同事类接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能
4. 具体同事类角色（ConcreteColleague）：抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互
   

2.2、实现

2.2.1、Colleague

package com.erlang.mediator;

/**
 * @description: 同事类
 * @author: erlang
 * @since: 2022-02-20 14:12
 */
public abstract class Colleague {

    protected Mediator mediator;

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    /**
     * 发送
     */
    public abstract void send();

    /**
     * 接收
     */
    public abstract void receive();
}

2.2.2、ConcreteColleague1

package com.erlang.mediator;

/**
 * @description: 具体同事类 1
 * @author: erlang
 * @since: 2022-02-20 14:19
 */
public class ConcreteColleague1 extends Colleague {

    @Override
    public void send() {
        System.out.println("具体同事类 1 发出请求。");
        // 请中介者转发
        mediator.relay(this);
    }

    @Override
    public void receive() {
        System.out.println("具体同事类 1 收到请求。");
    }
}

2.2.3、ConcreteColleague2

package com.erlang.mediator;

/**
 * @description: 具体同事类 2
 * @author: erlang
 * @since: 2022-02-20 14:19
 */
public class ConcreteColleague2 extends Colleague {

    @Override
    public void send() {
        System.out.println("具体同事类 2 发出请求。");
        // 请中介者转发
        mediator.relay(this);
    }

    @Override
    public void receive() {
        System.out.println("具体同事类 2 收到请求。");
    }
}

2.2.4、Mediator

package com.erlang.mediator;

import java.util.ArrayList;
import java.util.List;

/**
 * @description: 抽象中介者
 * @author: erlang
 * @since: 2022-02-20 14:10
 */
public abstract class Mediator {

    /**
     * 注册同事
     *
     * @param colleague 同事
     */
    public abstract void register(Colleague colleague);

    /**
     * 转发同事信息
     *
     * @param colleague 同事
     */
    public abstract void relay(Colleague colleague);

}

2.2.5、ConcreteMediator

package com.erlang.mediator;

import java.util.ArrayList;
import java.util.List;

/**
 * @description: 具体中介者实例
 * @author: erlang
 * @since: 2022-02-20 14:16
 */
public class ConcreteMediator extends Mediator {

    private List<Colleague> colleagues = new ArrayList<>();

    @Override
    public void register(Colleague colleague) {
        if (!colleagues.contains(colleague)) {
            colleagues.add(colleague);
            colleague.setMediator(this);
        }
    }

    @Override
    public void relay(Colleague colleague) {
        for (Colleague ob : colleagues) {
            if (!ob.equals(colleague)) {
                ob.receive();
            }
        }
    }
}

2.2.6、MediatorClient

package com.erlang.mediator;

/**
 * @description: 中介者客户端测试
 * @author: erlang
 * @since: 2022-02-20 14:21
 */
public class MediatorClient {

    public static void main(String[] args) {
        Mediator md = new ConcreteMediator();
        Colleague c1 = new ConcreteColleague1();
        Colleague c2 = new ConcreteColleague2();
        md.register(c1);
        md.register(c2);
        c1.send();
        System.out.println("-------------");
        c2.send();
    }
}

2.2.7、执行结果

具体同事类 1 发出请求。
具体同事类 2 收到请求。
-------------
具体同事类 2 发出请求。
具体同事类 1 收到请求。