设计模式-中介者模式

程序猿零零柒

已于 2024-06-05 23:14:47 修改

阅读量517

点赞数 13

文章标签：设计模式中介者模式

于 2024-06-05 22:06:00 首次发布

本文链接：https://blog.csdn.net/weixin_55157621/article/details/139482009

版权

一:基本介绍

1)用一个中介对象来封装一系列的对象交互,中介者使各个对象不需要显示的相互引用,从而使其耦合松散,而且可以独立的改变它们之间的交互

2)中介者模式属于行为型模式,使代码易于维护

3)比如MVC模式,C(Controller)是M(Model)和V(View视图)的中介者,在前后端交互时起到了中间人的作用

二:案例流程

1)创建ConcreMediator对象

2)创建各个同事对象,比如:Alarm, CoffeeMachine, TV

3)在创建同事类对象时,就直接通过构造器,加入到colleagueMap中

4)同事类对象,可以调用sendMessage,最终会去调用ConcreteMediator的getMessage方法

5)getMessage会根据接收到的同事对象发出的消息来协调调用其他的同事对象

三:具体案例

// 同事抽象类
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 this.mediator;
    }

    public abstract void sendMessage(int stateChange);

}

// 具体的同事类
public class Alarm extends Colleague{

    // 构造
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        // 创建Alarm时,同时将自己放入到ConcreteMediator中
        mediator.register(name, this);
    }

    public void sendAlarm(int stateChange) {
        sendMessage(stateChange);
    }
    @Override
    public void sendMessage(int stateChange) {
        // 调用的中介者对象的getMessage
        this.getMediator().getMessage(stateChange, this.name);
    }
}

// 具体的同事类
public class CoffeeMachine extends Colleague{

    // 构造
    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);
        // 创建Alarm时,同时将自己放入到ConcreteMediator中
        mediator.register(name, this);
    }

    public void sendCoffeeMachine(int stateChange) {
        sendMessage(stateChange);
    }
    @Override
    public void sendMessage(int stateChange) {
        // 调用的中介者对象的getMessage
        this.getMediator().getMessage(stateChange, this.name);
    }

    public void startCoffee() {
        System.out.println("开启咖啡工作...");
    }
}

// 具体的同事类
public class TV extends Colleague{

    // 构造
    public TV(Mediator mediator, String name) {
        super(mediator, name);
        // 创建Alarm时,同时将自己放入到ConcreteMediator中
        mediator.register(name, this);
    }

    public void sendTV(int stateChange) {
        sendMessage(stateChange);
    }
    @Override
    public void sendMessage(int stateChange) {
        // 调用的中介者对象的getMessage
        this.getMediator().getMessage(stateChange, this.name);
    }

    public void startTV() {
        System.out.println("开启电视工作...");
    }
}

public abstract class Mediator {
    // 将中介者对象加入到集合中
    public abstract void register(String colleagueName, Colleague colleague);

    // 接收消息,具体的同事对象发出
    public abstract void getMessage(int stateChange, String colleagueName);

    public abstract void sendMessage();
}

// 具体的中介者对象类
public class ConcreteMediator extends Mediator {
    // 放入了所有的同事对象
    private HashMap<String, Colleague> colleagueMap;
    private HashMap<String, String> interMap;

    public ConcreteMediator() {
        colleagueMap = new HashMap<>();
        interMap = new HashMap<>();
    }

    @Override
    public void register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName, colleague);
        if (colleague instanceof Alarm) {
            interMap.put("Alarm", colleagueName);
        } else if (colleague instanceof CoffeeMachine) {
            interMap.put("CoffeeMachine", colleagueName);
        } else if (colleague instanceof TV) {
            interMap.put("TV", colleagueName);
        }
    }

    // 具体中介者的核心方法
    // 根据得到的消息完成对应的任务
    // 中介者在这个方法中协调各个具体的同事对象完成任务
    @Override
    public void getMessage(int stateChange, String colleagueName) {
        // 闹钟发出的消息
        if (colleagueMap.get(colleagueName) instanceof Alarm) {
            if (stateChange == 0) {
                ((CoffeeMachine)colleagueMap.get("coffeeMachine")).startCoffee();
                ((TV)colleagueMap.get("TV")).startTV();
            }
        } else if (colleagueMap.get(colleagueName) instanceof TV) {
            // TV发出的消息在这处理
        }
    }

    @Override
    public void sendMessage() {

    }
}

public class ClientTest {
    public static void main(String[] args) {
        // 创建一个中介者对象
        ConcreteMediator mediator = new ConcreteMediator();
        // 创建一个闹钟,并且加入到对象ConcreteMediator的HashMap中
        Alarm alarm = new Alarm(mediator, "alarm");
        // 创建一个咖啡机,并且加入到对象ConcreteMediator的HashMap中
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");
        // 创建一个电视,并且加入到对象ConcreteMediator的HashMap中
        TV tv = new TV(mediator, "TV");

        // 让闹钟发出消息
        alarm.sendAlarm(0);
        
    }
}
运行结果:
开启咖啡工作...
开启电视工作...