前言

中介者模式，顧名思義，和中介有關。在我們日常生活中，也和中介有著各種各樣的聯系。比如買房，買車，出國留學，旅游等等。通過直接和中介接觸，省去了我們很多麻煩，也提高了辦事的效率。那么今天正好學習一下中介者模式。

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

中介者模式(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