JAVA23种设计模式之中介者模式

1. 中介者模式

中介者模式使用于降低多个对象和类之间的通信复杂度，该模式提供了一个类作为中介者，该类主要处理各个对象之间的通信，使各个对象直接不需要显性的相互引用，从而解耦。这种模式是对象的一种行为模式。换句话说中介者模式就是将对象直接的引用抽取到具体的中介者中

2. 中介者模式示例图

3. 中介者模式中的角色

• 抽象中介者角色：一般是一个接口或者抽象类，该接口用于与各个同事角色之间通信。
• 具体中介者角色：实现或者继承了抽象中介者角色的方法，来实现各个同事角色之间的协作。
• 抽象同事角色：一般是接口或者类，声明了各个具体同事类角色的公共方法，它一定包含一个对于抽象中介角色的引用。在开发来说就是包含一个抽象中介者角色的的参数。
• 具体同事角色：集成或者实现了抽象同事角色的方法，一般同事类会有多个，在中介者模式中，同事类智能通过中介者才能进行数据的传输。

4. 实例代码

场景：以现在比较火的智能家居指令为例。

• 抽象同事角色：

public abstract  class Colleague {
    private Mediator mediator;
    public String name;
    public Colleague(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }
    public Mediator getMediator() {
        return mediator;
    }
    public abstract void senMsg(int status);
}

• 具体同事角色：

 public class Door extends Colleague {
    public Door(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }
    public void openDoor(){
        System.out.println(name+"开门");
        senMsg(0);
    }
    public void CloseDoor( ){
        System.out.println("关门");
        senMsg(1);
    }
    @Override
    public void senMsg(int status) {
        this.getMediator().getMsg(status,name);
    }
}

public class Light extends Colleague {
    public Light(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }
    public void onLight(int lightStatus){
        System.out.println("开灯");
       senMsg(lightStatus);
    }
    public void offLight(int lightStatus){
        System.out.println("关灯");
        senMsg(lightStatus);
    }
    @Override
    public void senMsg(int status) {
        this.getMediator().getMsg(status,this.name);
    }
}

public class Airconditioning extends Colleague {
    public Airconditioning(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }
    public void onCondition(int ariStatus){
        System.out.println("开启空调");
        //senMsg(ariStatus);
    }
    public void offCondition(int ariStatus){
        System.out.println("关闭空调");
        //senMsg(ariStatus);
    }
    @Override
    public void senMsg(int status) {
        this.getMediator().getMsg(status,this.name);
    }
}

• 抽象中介者角色:

public  abstract class Mediator {
    public abstract void register(String colleagueName,Colleague colleague );
    public abstract void getMsg(int status,String colleagueName);
    public abstract void sendMsg();
}

• 具体中介者角色：

public class ConcreteMediator extends Mediator {
    private HashMap<String,Colleague>  colleagueHashMap;
    private HashMap<String,String> interMap;
    public ConcreteMediator() {
        colleagueHashMap= new HashMap<String,Colleague>();
        interMap = new HashMap<String,String>();
    }
    @Override
    public void register(String colleagueName, Colleague colleague) {
            colleagueHashMap.put(colleagueName,colleague);
            if (colleague instanceof Door){
                interMap.put("Door",colleagueName);
            }else if (colleague instanceof Light){
                interMap.put("Light",colleagueName);
            }else if (colleague instanceof Airconditioning){
                interMap.put("Airconditioning",colleagueName);
            }
    }
    @Override
    public void getMsg(int status, String colleagueName) {
        if (colleagueHashMap.get(colleagueName) instanceof  Door){
            if (status==0){
                ((Light)(colleagueHashMap.get(interMap.get("Light")))).onLight(status);
                ((Airconditioning)(colleagueHashMap.get(interMap.get("Airconditioning")))).onCondition(status);
            }else if (status==1){
                ((Light)(colleagueHashMap.get(interMap.get("Light")))).offLight(status);
                ((Airconditioning)(colleagueHashMap.get(interMap.get("Airconditioning")))).offCondition(status);
            }
        }else if (colleagueHashMap.get(colleagueName) instanceof Light) {


        } else if (colleagueHashMap.get(colleagueName) instanceof Airconditioning) {


        }
    }
    @Override
    public void sendMsg() {

    }
}

5. 中介者模式的优缺点

优点：
降低了类的复杂度，将一对多转换为一对一，是对象之间的关系便于理解和维护；对具体同事类进行解耦合，具体同事类都相对独立。
缺点：
中介者角色在改模式中起主导作用，如果存在过于复杂的关系，会导致中介者类变得越加庞大，以至于难以维护。而且中介者一旦出现问题会导致整个系统无法运行。

附录：

public abstract class AbsColleague {
    protected  int number;
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public abstract  void setNumber(int number, AbsMediator mediator);
}

public class ColleagueA extends AbsColleague {
    @Override
    public void setNumber(int number, AbsMediator mediator) {
        this.number=number;
        mediator.AeffectB();
    }
}

public  abstract  class AbsMediator  {
    protected AbsColleague A;
    protected  AbsColleague B;
    public AbsMediator(AbsColleague colleagueA, AbsColleague colleagueB) {
          A = colleagueA;
          B = colleagueB;
    }
    public abstract void AeffectB();
    public abstract void  BeffectA();
}

public class ColleagueB extends AbsColleague {
    @Override
    public void setNumber(int number, AbsMediator mediator) {
        this.number=number;
        mediator.BeffectA();
    }
}

public class Mediator extends AbsMediator {
    public Mediator(AbsColleague colleagueA, AbsColleague colleagueB) {
        super(colleagueA, colleagueB);
    }
    @Override
    public void AeffectB() {
        int num = A.getNumber();
        B.setNumber(num*100);
    }
    @Override
    public void BeffectA() {
        int num = B.getNumber();
        A.setNumber(num/100);
    }
}

public class Main {
    public static void main(String[] args) {
        AbsColleague absColleagueA = new ColleagueA();
        AbsColleague absColleagueB = new ColleagueB();
        AbsMediator absMediator = new Mediator(absColleagueA,absColleagueB);
        absColleagueA.setNumber(155,absMediator);
        absMediator.AeffectB();
        System.out.println(absColleagueB.getNumber());
    }
}