中介者模式

定义

定义一个中介对象来封装一系列对象之间的交互，使原有对象解耦，且可以独立的改变它们之间的交互。

架构

抽象中介者：是中介者的接口，提供同事对象注册与转发同事对象信息的抽象方法；
具体中介者：定义一个容器来管理对象，协调各个同事角色之间的交互关系，因此依赖于同事角色；
抽象同事：保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能；
具体同事：当需要与其他同事对象交互的时候由中介者对象负责后续的交互；

应用场景

1、当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时；
2、当想创建一个运行于多个类之间的对象，又不想生成新的子类时；

代码

以老板通过中介找工人为例模拟中介者模式

Mediator（抽象中介者）

/**
 *
 * Description:
 *      抽象中介者
 * @author: mushi
 * @Date: 2021/2/22 13:24
 */
public abstract class Mediator {

    /**添加资源*/
    public abstract void register(Person person);

    /**转发消息*/
    public abstract void sendMsg(Person person,String msg);

}

MediatorA（具体中介者）

/**
 *
 * Description:
 *      中介
 * @author: mushi
 * @Date: 2021/2/22 13:30
 */
public class MediatorA extends Mediator{

    //中介手中的所有人力资源
    private List<Person> list = new ArrayList<>();

    //添加资源,人和中介绑定
    @Override
    public void register(Person person) {
        if (!list.contains(person)){
            list.add(person);
            person.setMediator(this);
        }
    }

    //介绍
    @Override
    public void sendMsg(Person person,String msg) {
        System.out.println("中介收到消息："+msg+">>>>开始转发给"+person.getClass().getSimpleName());
        person.receive(msg);
    }

}

Person（抽象同事）

/**
 *
 * Description:
 *      抽象同事类
 * @author: mushi
 * @Date: 2021/2/22 13:31
 */
public abstract class Person {

    //都要有同一个中介的联系方式
    private Mediator mediator;

    public Mediator getMediator() {
        return mediator;
    }

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

    /**接收中介的消息*/
    public abstract void receive(String msg);

    /**联系中介*/
    public abstract void callMediator(Person person,String msg);



}

Boss（具体同事）

/**
 *
 * Description:
 *          具体同事类
 * @author: mushi
 * @Date: 2021/2/22 13:29
 */
public class Boss extends Person {

    @Override
    public void receive(String msg) {
        System.out.println("老板收到中介消息："+msg);
    }

    @Override
    public void callMediator(Person person,String msg) {
        System.out.println("老板联系中介："+msg);
        Mediator mediator = super.getMediator();
        //中介转发老板消息给员工
        mediator.sendMsg(person,msg);
    }

}

Worker（具体同事）

/**
 *
 * Description:
 *      具体同事类
 * @author: mushi
 * @Date: 2021/2/22 13:29
 */
public class Worker extends Person {

    @Override
    public void receive(String msg) {
        System.out.println("员工收到中介消息："+msg);
    }

    @Override
    public void callMediator(Person person,String msg) {
        System.out.println("员工联系中介："+msg);
        Mediator mediator = super.getMediator();
        mediator.sendMsg(person,msg);
    }

}

Test

/**
 *
 * Description:
 *
 * @author: mushi
 * @Date: 2021/2/22 13:45
 */
public class Test {

    public static void main(String[] args) {
        //创建一个中介
        Mediator mediatorA = new MediatorA();
        //创建老板和员工并添加到同一个中介人力资源里
        Person boss = new Boss();
        Person worker = new Worker();
        mediatorA.register(boss);
        mediatorA.register(worker);
        //向中介发消息 中介转给对应资源
        String msg = "招牛郎";
        String msg2 = "面试牛郎";
        boss.callMediator(worker,msg);
        worker.callMediator(boss,msg2);
    }

}

总结

就以找工作为例，
老板想找员工—先联系中介，
中介收到老板要找员工的消息，
求职者找工作—先联系中介，
中介收到求职者要找工作的消息，
中介管理着要招员工的老板和要找工作的员工，
中介者可以通过一定的策略将求职者和招聘者关联起来。

所以，在中介模式中，两个要有关联的对象并不直接联系，而是通过中介来取得联系，那么中介就必须要同时管理着要取得联系的对象。