23天学习23种设计模式——中介者模式

前言

中介者模式，顾名思义，和中介有关。在我们日常生活中，也和中介有着各种各样的联系。比如买房，买车，出国留学，旅游等等。通过直接和中介接触，省去了我们很多麻烦，也提高了办事的效率。那么今天正好学习一下中介者模式。

是什么——什么是中介者模式

中介者模式(Mediator Pattern):用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

中介者模式

中介者模式种包括如上图几种角色：

• Mediator：抽象中介者类
• ConcreteMediator：具体中介者类
• Colleague:抽象同事类
• ConCreteColleague:具体同事类

为什么——为什么要用中介者模式

对象之间存在很强的关联性，会导致系统结构复杂，拓展性差，对象的可重用性差。为了减少对象之间的关联性，使系统变成一个松耦合的系统，于是就有了中介者模式。

怎么用——怎么实现中介者模式

首先是一个抽象中介者类：

/**
 * 抽象中介者类
 */
public interface Mediator {

    /**
     * 让某同事类做相关操作
     * @param name
     */
    void operation(String name);

    /**
     * 注册同事类
     * @param name
     * @param colleague
     */
    void register(String name,Colleague colleague);


}

然后就是抽象同事类：

/**
 * 抽象同事类
 */
public abstract class Colleague {

    /**
     * 持有的中介类对象
     */
    protected Mediator mediator;

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

    /**
     * 自身的相关操作
     */
    public abstract void selfAction();

    /**
     * 请求其他同事类的操作
     */
    public abstract void outerAction();

    /**
     * 获得同事类的名字
     * @return
     */
    public String getName(){
        return getClass().getName();
    }




}

有了抽象中介类和同事类，那么我们就要去实现它们，下面就是具体中介类以及具体同事类：

/**
 * 具体中介者类
 */
public class ConcreteMediator implements Mediator{

    private Map<String,Colleague> map = new HashMap<>();

    @Override
    public void operation(String name) {
        Colleague colleague = map.get(name);
        if(colleague==null){
            System.out.println("Colleague "+name+" not found!");
        }else{
            colleague.selfAction();
        }
    }

    @Override
    public void register(String name, Colleague colleague) {
         map.put(name,colleague);
    }
}

public class ConcreteColleagueA extends Colleague {


    @Override
    public void selfAction() {
        System.out.println("A's self action");
    }

    @Override
    public void outerAction() {
        System.out.println("A's outer Action");
        System.out.println("A request B's self Action");
       //请求同事类B的操作
        mediator.operation(ConcreteColleagueB.class.getName());
    }

    @Override
    public String getName() {
        return super.getName();
    }
}

public class ConcreteColleagueB extends Colleague{


    @Override
    public void selfAction() {
        System.out.println("B's self Action");
    }

    @Override
    public void outerAction() {
       System.out.println("B's outer Action");
    }

    @Override
    public String getName() {
        return super.getName();
    }
}

最后让我们模拟一下同事类A通过中介者对象请求同事类B的操作。

public class Client {
    public static void main(String[] args) {

        Mediator mediator = new ConcreteMediator();
        ConcreteColleagueA concreteColleagueA = new ConcreteColleagueA();
        concreteColleagueA.setMediator(mediator);

        ConcreteColleagueB concreteColleagueB = new ConcreteColleagueB();
        concreteColleagueB.setMediator(mediator);

        //同事类A请求同事类B的操作
        concreteColleagueA.outerAction();


      
    }
}

运行结果：
比如同事A请求同事B的操作，就是在A的outerAction方法中向中介者M请求B的操作，调用了Mediator类的operation方法，在其中，中介者通过查找之前注册的同事类，若能找到B，则让B执行操作，否则，则告知没有相关同事类。

image.png