设计模式学习笔记-中介者模式

时间 2020-06-10 标签设计模式学习笔记中介

智能家庭项目

智能家庭包括各类设备，闹钟、咖啡机、电视机、窗帘等
主人要看电视时，各个设备能够协同工做，自动完成看电视的准备工做好比：
闹钟响起–>咖啡机作咖啡–>窗帘自动落下–>电视机开始播放

传统方案解决问题

存在问题

当各个电器对象有多种状态改变时，相互调用关系复杂
各个电器对象彼此联系，你中有我，我中有你不利于松耦合
各个对象之间所传递的消息容易混乱
当系统增长一个新的电器对象时，或者执行流程改变时，代码不易维护和扩展

中介者模式

介绍

中介者模式用一个中介对象封帐一系列对象交互。中介者使各个对象不须要显示的相互引用，从而使其松耦合，能够独立的改变他们之间的交互
中介者模式属于行为型模式，使其代码易维护
好比MVC模式，C（Controller控制器）是M（Model模型）和V（View视图）的中介者，在先后端交互时起到了中间人的做用

原理类图

Mediator就是抽象中介者，定义了同事对象到中介者对象的接口
Colleague是抽象同事类
ConcreteMediator是具体中介者对象，实现抽象方法，他须要知道全部的具体同事类，即以一个集合来管理，并接受某个同事对象消息，完成相应的任务
ConcreteColleague具体同事类，每一个同事只知道本身的行为，而不了解其余同事类的行为，可是他们依赖中介者对象

中介者模式解决问题

类图

代码实现
1.Mediatorjava

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

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

	public abstract void SendMessage();
}

ConcreteMediatorweb

//具体的中介者类
public class ConcreteMediator extends Mediator {
	//集合，放入全部的同事对象
	private HashMap<String, Colleague> colleagueMap;
	private HashMap<String, String> interMap;

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

	@Override
	public void Register(String colleagueName, Colleague colleague) {
		// TODO Auto-generated method stub
		colleagueMap.put(colleagueName, colleague);

		// TODO Auto-generated method stub

		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);
		} else if (colleague instanceof Curtains) {
			interMap.put("Curtains", colleagueName);
		}

	}

	//具体中介者的核心方法
	//1. 根据获得消息，完成对应任务
	//2. 中介者在这个方法，协调各个具体的同事对象，完成任务
	@Override
	public void GetMessage(int stateChange, String colleagueName) {
		// TODO Auto-generated method stub

		//处理闹钟发出的消息
		if (colleagueMap.get(colleagueName) instanceof Alarm) {
			if (stateChange == 0) {
				((CoffeeMachine) (colleagueMap.get(interMap
						.get("CoffeeMachine")))).StartCoffee();
				((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();
			} else if (stateChange == 1) {
				((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();
			}

		} else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
			((Curtains) (colleagueMap.get(interMap.get("Curtains"))))
					.UpCurtains();

		} else if (colleagueMap.get(colleagueName) instanceof TV) {//若是TV发现消息

		} else if (colleagueMap.get(colleagueName) instanceof Curtains) {
			//若是是以窗帘发出的消息，这里处理...
		}

	}

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

	}

}

2.Colleague后端

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

Alarmide

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

	//构造器
	public Alarm(Mediator mediator, String name) {
		super(mediator, name);
		// TODO Auto-generated constructor stub
		//在建立Alarm 同事对象时，将本身放入到ConcreteMediator 对象中[集合]
		mediator.Register(name, this);
	}

	public void SendAlarm(int stateChange) {
		SendMessage(stateChange);
	}

	@Override
	public void SendMessage(int stateChange) {
		// TODO Auto-generated method stub
		//调用的中介者对象的getMessage
		this.GetMediator().GetMessage(stateChange, this.name);
	}

}

Curtainssvg

public class Curtains extends Colleague {

	public Curtains(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);
	}

	public void UpCurtains() {
		System.out.println("I am holding Up Curtains!");
	}

}

TVthis

public class TV extends Colleague {

	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);
	}

	public void StartTv() {
		// TODO Auto-generated method stub
		System.out.println("It's time to StartTv!");
	}

	public void StopTv() {
		// TODO Auto-generated method stub
		System.out.println("StopTv!");
	}
}

CoffeeMachinespa

public class CoffeeMachine extends Colleague {

	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);
	}

	public void StartCoffee() {
		System.out.println("It's time to startcoffee!");
	}

	public void FinishCoffee() {

		System.out.println("After 5 minutes!");
		System.out.println("Coffee is ok!");
		SendMessage(0);
	}
}

3.Client设计

public class ClientTest {

	public static void main(String[] args) {
		//建立一个中介者对象
		Mediator mediator = new ConcreteMediator();
		
		//建立Alarm 而且加入到 ConcreteMediator 对象的HashMap
		Alarm alarm = new Alarm(mediator, "alarm");
		
		//建立了CoffeeMachine 对象，并 且加入到 ConcreteMediator 对象的HashMap
		CoffeeMachine coffeeMachine = new CoffeeMachine(mediator,
				"coffeeMachine");
		
		//建立 Curtains , 并 且加入到 ConcreteMediator 对象的HashMap
		Curtains curtains = new Curtains(mediator, "curtains");
		TV tV = new TV(mediator, "TV");
		
		//让闹钟发出消息
		alarm.SendAlarm(0);
		coffeeMachine.FinishCoffee();
		alarm.SendAlarm(1);
	}

}

中介者模式注意事项

多个类相互耦合，会造成网状结构，使用中介者模式将网状结构分离成星型结构
减小类之间的依赖，下降了耦合，符合迪米特法则
中介者承担较多责任，一旦中介者出现问题，整个系统都受影响
若是设计不当，中介者对象会特别复杂