设计模式_18_中介者模式

基本介绍

1. 中介者模式(Mediator Pattern)，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互
2. 中介者模式属于行为型模式，使代码易于维护
3. 比如MVC模式，C (Controller控制器)是M (Model模型)和V (View视图)的中介者，在前后端交互时起到了中间人的作用

image.png

例子：
智能家庭项目:
1)智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等
2)主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流
程为:闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放

实现：

image.png

public abstract class Mediator {    
    
    public abstract void getMessage(int stateChange,String name);
    
    public abstract void register(String name,Colleage colleage);
    
    public abstract void sendMessage();
}

public abstract class Colleage {

    private Mediator mediator;
    public String name;
    public Colleage(Mediator mediator, String name) {
        super();
        this.mediator = mediator;
        this.name = name;
    }

public class ConcereteMediator extends Mediator{
    
     private HashMap<String, Colleage> map;
     private HashMap<String, String> interMap;

     public ConcereteMediator() {
        // TODO Auto-generated constructor stub
        map = new HashMap<>();
        interMap = new HashMap<>();
     }
    
    @Override
    public void getMessage(int stateChange,String name) {
        // TODO Auto-generated method stub
        Colleage colleage = map.get(name);
        if (colleage instanceof Alarm) {
            if (stateChange == 0) {
                ( (TV)(map.get(interMap.get("TV"))) ).play();
                ( (CoffeeMachine)(map.get(interMap.get("CoffeeMachine"))) ).play();
            }else if (stateChange == 1) {
                ( (TV)(map.get(interMap.get("TV"))) ).stop();
                ( (CoffeeMachine)(map.get(interMap.get("CoffeeMachine"))) ).stop();
            }
        }else if(colleage instanceof TV){
            
        }
        
    }
    
    public void register(String name,Colleage colleage) {
        map.put(name, colleage);
        
        if (colleage instanceof Alarm) {
            interMap.put("Alarm", name);
        }else if (colleage instanceof TV) {
            interMap.put("TV", name);       
        }else if(colleage instanceof CoffeeMachine){
            interMap.put("CoffeeMachine", name);
        }
    }

    @Override
    public void sendMessage() {
        // TODO Auto-generated method stub
        
    }

}
    
    public Mediator getMediator(){
        return this.mediator;
    }
    
    public abstract void sendMessage(int stateChange);
}

public class Alarm extends Colleage {

    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        // TODO Auto-generated constructor stub
        mediator.register(name, this);
    }
    

    @Override
    public void sendMessage(int stateChange) {
        // TODO Auto-generated method stub
        this.getMediator().getMessage(stateChange,this.name);
    }
    
    @Override
    public Mediator getMediator() {
        // TODO Auto-generated method stub
        return super.getMediator();
    }
}

public class TV extends Colleage{

    public TV(Mediator mediator, String name) {
        super(mediator, name);
        // TODO Auto-generated constructor stub
        mediator.register(name, this);
    }

    @Override
    public void sendMessage(int stateChange) {
        // TODO Auto-generated method stub
        this.getMediator().getMessage(stateChange,this.name);
    }
    
    @Override
    public Mediator getMediator() {
        // TODO Auto-generated method stub
        return super.getMediator();
    }

    public void play() {
        // TODO Auto-generated method stub
        System.out.println("电视开始播放...");
    }
    
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("电视停止播放");
    }

}

public class CoffeeMachine extends Colleage {

    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);
        // TODO Auto-generated constructor stub
        mediator.register(name, this);
    }

    @Override
    public void sendMessage(int stateChange) {
        // TODO Auto-generated method stub
        this.getMediator().getMessage(stateChange,this.name);
    }
    
    @Override
    public Mediator getMediator() {
        // TODO Auto-generated method stub
        return super.getMediator();
    }

    public void play() {
        // TODO Auto-generated method stub
        System.out.println("咖啡机开始工作...");
    }
    
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("咖啡机停止工作...");
    }

}

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

        Mediator mediator = new ConcereteMediator();
        
        Alarm alarm = new Alarm(mediator, "Alarm");
        
        TV tv = new TV(mediator, "Tv");
        
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeMachine");
        
        alarm.sendMessage(0);
        System.out.println("----------------");
        alarm.sendMessage(1);
    }
}

中介者模式的注意事项和细节

1. 多个类相互耦合，会形成网状结构,使用中介者模式将网状结构分离为星型结构，进行解耦
2. 减少类间依赖，降低了耦合，符合迪米特原则
3. 中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响
4. 如果设计不当，中介者对象本身变得过于复杂，这点在实际使用时，要特别注意