"围观"设计模式(25)--行为型之中介者模式（Mediator Pattern）

用一个对象封装一系列的对象交互，中介者使对象不需要显示的相互作用，从而使其耦合松散，而且可以独立的改变他们之间的独立。

个人理解

当多个对象之间存在着过多的耦合时，可以通过中介者模式进行解耦，将具体的对象之间的耦合转为中介者与具体对象的耦合，假如说之前是三个对象的相互之间的耦合，转为中介者与具体类的耦合之后，从耦合性上大大的降低了，这样如果再来对其进行修改的话，那么变更部分主要在中介者部分，从而使得该结构更加稳定。

角色分析

中介者角色分以下几个部分：

1. Mediator抽象中介者角色：抽象中介者角色定义统一的接口，用于各同事角色之间的通信。

2. Concrete Mediator具体中介者角色：具体中介者角色通过协调各同事角色实现写作行为，依赖于各同事角色。

3. Colleague同事角色：每个同事类的任务中，包括自身需要完成的功能，以及自己完不成要交给中介者进行其余处理的部分功能。

案例解析

案例一：购销系统应用中介者模式

案例背景介绍

由公司购销系统来讲，购入商品的时候，库存需要相应的增加，此处属于依赖其他对象的关系。需要清仓的时候，一方面，需要停止进货，打折促销完成清仓任务。从这几部来看实体类（Purchase、Sale、Store）三者之间如果不采用中介者模式的时候，需要在完成购入的任务时，使得Purchase类依赖Store类。在完成清仓并促销等任务时，使得Store中依赖Purchase类和Sale类。这样的依赖关系就显得过于复杂，而且不容易管理。

使用中介者模式之后，就会使得三者之间的依赖关系纯粹而简单，只与中介者类耦合，其余的操作也可以在中介者类中进行完成。这样既方便管理与维护，也降低了耦合度提高了稳定性。

主要代码

相当于同事角色抽象类。定义公共的属性和制定构造方法。

public abstract class AbstractEmployee {

	protected AbstractMediator mediator;

	public AbstractEmployee(){}

	public AbstractEmployee(AbstractMediator mediator) {
		this.mediator = mediator;
	}

}

具体同事角色实现类

public class PurchaseMan extends AbstractEmployee {

	public PurchaseMan(){

	}

	public PurchaseMan(AbstractMediator mediator) {
		super(mediator);
	}

	public void buy(int i) {
		this.mediator.executor("buy", i);
	}

	public void stopBuy() {
		System.out.println("停止购买");
	}

}
public class SaleMan extends AbstractEmployee {

	public SaleMan(){}

	public SaleMan(AbstractMediator mediator) {
		super(mediator);
	}

	public int getStatus() {
		Random random = new Random();
		int num = random.nextInt(120);
		return num;
	}

	public void sale(Integer num) {
		this.mediator.executor("sale", num);
	}
}
public class StoreMan extends AbstractEmployee {

	private int num = 100;

	public StoreMan() {

	}

	public StoreMan(AbstractMediator mediator) {
		super(mediator);
	}

	public void increaseStore(Integer num) {

		this.num += num;
	}

	public Integer getNum() {

		return this.num;
	}

	public void clearStore() {

		this.mediator.executor("sell", this.num);
	}

	public void decreaseStore(Integer num2) {

		this.num -= num2;
	}

}

中介者角色抽象类：抽象中介者角色定义统一的接口，用于各同事角色之间的通信。

public abstract class AbstractMediator {

	protected static PurchaseMan purchase = new PurchaseMan();
	protected static SaleMan sale = new SaleMan();
	protected static StoreMan store = new StoreMan();

	public abstract void executor(String exeStr, Object...obj);
}

Concrete Mediator具体中介者角色：具体中介者角色通过协调各同事角色实现写作行为，依赖于各同事角色。

public class Mediator extends AbstractMediator {

	@Override
	public void executor(String exeStr, Object... obj) {
		// 购入
		if("buy".equals(exeStr)) {
			this.buySomething((Integer)obj[0]);
		}
		// 卖出
		else if("sell".equals(exeStr)) {
			this.sellSomething((Integer)obj[0]);
		}
		// 清仓
		else if("clear".equals(exeStr)) {
			this.clear();
		}
		// 打折促销
		else if("sale".equals(exeStr)) {
			this.sale((Integer)obj[0]);
		}

	}

	private void sale(int num) {
		System.out.println("便宜卖出" + num);
	}

	private void clear() {
		System.out.println("clear --- start");
		if(store.getNum() > 0) {
			System.out.println("清仓>>" + store.getNum());
			purchase.stopBuy();
			sale.sale(store.getNum());
			store.decreaseStore(store.getNum());
		}
		else {
			System.out.println("已经清仓");
		}
		System.out.println("clear --- stop");
	}

	private void sellSomething(Integer num) {

		System.out.println("sell ---- start");
		if(store.getNum() <= num) {

			System.out.println("买入" + (num - store.getNum()));
			System.out.println("清仓");
			purchase.buy(num - store.getNum());
			store.clearStore();
		}
		else {
			System.out.println("卖出" + num);
			store.decreaseStore(num);
		}
		System.out.println("sell ---- end");
	}

	private void buySomething(Integer num) {
		System.out.println("buy ---- start");
		if(sale.getStatus() > 100) {
			System.out.println("购入" + num);
			store.increaseStore(num);
		}
		else{
			System.out.println("购入" + num / 3);
			store.increaseStore(num / 3);
		}
		System.out.println("buy ---- end");
	}

}

测试类

public class MainTest {

	public static void main(String[] args) {

		Mediator mediator = new Mediator();

		PurchaseMan purchase = new PurchaseMan(mediator);
		purchase.buy(100);

		SaleMan sale = new SaleMan(mediator);
		sale.sale(100);

		StoreMan store = new StoreMan(mediator);
		store.clearStore();
	}
}

案例二：模拟飞机场调度

案例背景

飞机场作为各个飞机落地时的中介是非常重要的，如果当前跑道上有飞机在降落，那么达到的其他的飞机不能进行降落，得等待该飞机完成降落后，刚到达的飞机才能进行安全的降落。本例通过多线程的方式进行中介者模式的运用。模拟飞机的降落过程。

主要代码

相当于同事类的抽象类。定义了中介者以及 必要的一些飞机落地的方法。

public abstract class Airplane {

	protected static AriportMediator mediator = new AriportMediator();
	/**
	 * 准备降落
	 */
	public abstract  void prepareLanded();

	/**
	 * 检查是否安全
	 */
	public abstract boolean checkIsSafe();

	/**
	 * 着陆
	 */
	public abstract void landing();

	/**
	 * 继续飞行，直到确认安全为止
	 */
	public abstract void continueToFly();

	public void landingMethod(){
		this.prepareLanded();
		if(this.checkIsSafe()){
			landing();
		}else{
			continueToFly();
		}

	}
}

public class CNAirPlane extends Airplane{

	@Override
	public void prepareLanded() {
		System.out.println("CNAirPlane--准备着陆！");
		this.mediator.setAirPlaneWaitingLoading(this);
	}

	@Override
	public synchronized boolean checkIsSafe() {
		return this.mediator.checkIsSafe();
	}

	@Override
	public synchronized void landing() {
		this.mediator.setStatus(0);
		System.out.println("CNAirPlane--正在着陆！");
		try {
			new Thread().sleep(2000);
		} catch (Exception e) {
			e.printStackTrace();
		}
		this.mediator.removeAirplane(this);
		System.out.println("CNAirPlane--着陆完成！");
		this.mediator.setStatus(1);
	}

	@Override
	public void continueToFly() {
		System.out.println("CNAirPlane--继续飞行！");
		while(true){
			if(this.mediator.checkIsSafe()){
				landing();
				break;
			}
		}
	}

}
public class CNSHAirPlane extends Airplane{

	@Override
	public void prepareLanded() {
		System.out.println("CNSHAirPlane--准备着陆！");
		this.mediator.setAirPlaneWaitingLoading(this);
	}

	@Override
	public boolean checkIsSafe() {
		return this.mediator.checkIsSafe();
	}

	@Override
	public synchronized void landing() {
		System.out.println("CNSHAirPlane--正在着陆！");
		try {
			new Thread().sleep(1000);
		} catch (Exception e) {
			e.printStackTrace();
		}
		this.mediator.setStatus(0);
		this.mediator.removeAirplane(this);
		System.out.println("CNSHAirPlane--着陆完成！");
	}

	@Override
	public void continueToFly() {
		System.out.println("CNSHAirPlane--继续飞行！");
		while(true){
			if(this.mediator.checkIsSafe()){
				landing();
				break;
			}
		}
	}
}

中介者角色，完成多个飞机角色的交互，协调之间的降落关系，使得飞机可以安全的落地。

public class AriportMediator {

	// 记录飞机申请着陆的序列
	private static List<Object> airPlaneWaitingLoading = new ArrayList<Object>();
	// 飞机着陆状态0：表示不可以着陆，1表示可以着陆。
	private static int airPlaneLoadingStatus = 1;

	public static List<Object> getAirPlaneWaitingLoading() {
		return airPlaneWaitingLoading;
	}

	public static synchronized void setAirPlaneWaitingLoading(Object airPlane) {
		airPlaneWaitingLoading.add(airPlane);
		// System.out.println(airPlaneWaitingLoading);
	}

	public static synchronized void removeAirplane(Object airPlane) {
		airPlaneWaitingLoading.remove(airPlane);
		// System.out.println(airPlaneWaitingLoading);
	}

	public synchronized boolean checkIsSafe() {
		// 正在准备着陆的飞机
		if(airPlaneWaitingLoading != null && airPlaneWaitingLoading.size() > 1 || airPlaneLoadingStatus == 0){
			return false;
		}
		else{
			return true;
		}
	}

	public synchronized void setStatus(int status){
		airPlaneLoadingStatus = status;
		// System.out.println("状态：" + airPlaneLoadingStatus);
	}
	public int getStatus(){
		return airPlaneLoadingStatus;
	}

}

测试类

public class MainTest {

	public static void main(String[] args) {
		new Thread(new Runnable() {

			@Override
			public void run() {
				Airplane airPlane = new CNAirPlane();
				airPlane.landingMethod();
			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				Airplane airPlane2 = new CNSHAirPlane();
				airPlane2.landingMethod();
			}
		}).start();

	}
}

中介者模式优点

减少类之间的依赖关系，把原来的一对多的依赖关系变成一对一的依赖关系，减少了依赖降低了耦合度，提高了稳定性。

中介者模式缺点

导致中介者类膨胀，逻辑过于复杂化，同事类越多，那么中介者中逻辑越复杂。

设计模式代码下载

设计模式源码下载

时间： 2024-12-21 23:19:09

"围观"设计模式(25)--行为型之中介者模式（Mediator Pattern）的相关文章

设计模式(行为型)之中介者模式(Mediator Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(行为型)之职责链模式(Chain of Responsibility Pattern)>http://blog.csdn.net/yanbober/article/details/45531395 概述 如果对象之间的联系呈现为网状结构,存在大量的多对多联系,在网状结

&quot;围观&quot;设计模式(22)--行为型之职责链模式（Chain Of Responsibility Pattern）

责任链模式在面向对象程式设计里是一种软件设计模式,它包含了一些命令对象和一系列的处理对象.每一个处理对象决定它能处理哪些命令对象,它也知道如何将它不能处理的命令对象传递给该链中的下一个处理对象.该模式还描述了往该处理链的末尾添加新的处理对象的方法.----WIKIPEDIA 个人的理解 责任链模式用到了链表的数据结构,存在一定的次序性,A->B->C这样的一条链表,在责任链模式中,请求交给A进行处理,如果A处理不了交给B,B如果处理的了进行处理,否则交给C处理,模式的关键在于构建这样的一个链表

二十三种设计模式[17] - 中介者模式(Mediator Pattern)

前言 在开发软件的过程中,我们通常会将类设计的比较单纯,使其复用性更高.但类间的相互引用又使得类本身在没有其他类的支持下不能正常工作,导致其复用性降低.所以为了提高类的复用性我们需要尽可能的减少对其它类的引用,也就是说我们常说的解耦.中介者模式,顾名思义,就是存在一个类似中介的角色,类与类之间不直接交互而是通过中介进行间接的交互,也就意味着类与类之间不需要存在显示的引用,以达到松耦合的目的. 中介者模式,对象行为型模式的一种.在<设计模式 - 可复用的面向对象软件>一书中将之描述为"

[设计模式] 中介者模式 Mediator Pattern

在GOF的<设计模式:可复用面向对象软件的基础>一书中对中介者模式是这样说的:用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 我们都知道,面向对象设计鼓励将行为分布到各个对象中.但是,这种分布可能会导致对象间有许多连接.在最坏的情况下,每一个对象都知道其他所有对象,就造成了复杂的关联关系.虽然将一个系统分割成许多对象通常可以增强可复用性,但是对象间相互连接的激增又会降低其可复用性.大量的相互连接使得一个对象似乎不太

23种设计模式--中介者模式-Mediator Pattern

一.中介者模式的介绍     中介者模式第一下想到的就是中介,房子中介,婚姻中介啊等等,当然笔者也希望来个婚姻中介给我介绍一个哈哈哈,,回归正题中介者模式分成中介者类和用户类,根据接口编程的方式我们再把中介和用户类分成2个类,这样就成了抽象中介者角色,具体中介者角色.抽象同事类和具体同事类.来几个例子比如说各种游戏平台,还有我们最熟悉的QQ平台,等等这些都是中介者模式的具体应用,中介者模式常用于处理通信之间复杂有关联的业务,这样就会存在一个缺点比如说因为中介者处理了好多用户之间的关系,一但发生错

18.中介者模式(Mediator Pattern)

using System; namespace ConsoleApplication9 { class Program { /// <summary> /// 中介者模式,定义了一个中介对象来封装一系列对象之间的交互关系. /// 中介者使各个对象之间不需要显式地相互引用,从而使耦合性降低,而且可以独立地改变它们之间的交互行为. /// </summary> /// <param name="args"></param> static v

&quot;围观&quot;设计模式(8)--创建型之简单工厂模式、工厂方法模式、抽象工厂模式

工厂模式的核心思想在我认为是将类创建的权利授予给工厂类,其他的类不允许创建,授予了权限的类创建好之后,需要某些的对象的时候,可以去工厂当中去取.也就是像一个工厂一样,用的人不需要关心对象怎么来的,你只需要关心怎么用就好了.工厂模式细分为三种,简单工厂.工厂方法.抽象工厂三种模式.这三种模式比较相似,往往会引发混淆,本文主要结合实际的例子去进行区分.理清三者之间的关系与适用范围. 概述 简单工厂 对于简单工厂,我个人的理解是,直接实现一个方法,要生产什么由这个方法以及传入的参数来决定. 工厂方法

[设计模式]&lt;8&gt;. C++与中介者模式(mediator pattern)

意图:用一个中介者对象封装一系列的对象交互.中介者使各对象不需要显式的相互引用,从而减小耦合. 原文:默默的EEer 地址:http://www.cnblogs.com/hebaichuanyeah/p/6091506.html 实际就是指,利用一个中介者对象来连接两个对象的操作.例如需求是,A对象更新/改变了,B对象也跟着相应的更新/改变,不通过直接调用B对象 一个例子,详见注释 #include <iostream> using namespace std; class Colleague

&quot;围观&quot;设计模式(31)--行为型设计模式总结（模板、观察者、策略、状态、责任链、命令、访问者、中介者、备忘录、解释器）

设计模式源代码下载 设计模式源代码下载 1  模板方法模式 模板方法模式定义了一个算法的步骤,并允许子类别为一个或多个步骤提供其实践方式.让子类别在不改变算法架构的情况下,重新定义算法中的某些步骤.----WIKIPEDIA 个人理解 模板方法模式相对而言比较简单,一般的都是由抽象类定义好模板方法,然后,子类通过继承并实现其父类中定义好的模板中需要执行的具体的方法,调用子类对象的模板方法时,会执行该类中的具体实现的方法.这个模式我个人的感觉有点像是面向过程的操作,执行完一道工序,接着下一道工序.