设计模式笔记:中介者模式

中介者模式

我的理解:

在多对多关系下的交互处理,在随着交互者的增加,复杂程度急剧增加,这时候如果还是使用一般模式,将无法维护,所以这时候就需要使用中介者模式。其中,交互者(同事类)除了本身的属性方法外,必须有一个访问中介者的接口,进行与中介者进行交互,而。中介者有着对所有交互者进行修改的方法(当然中介者中保存着所有的交互者对象,可以使用容器进行的);

这样,当一个交互者想通知其他所有人的时候,只要内部调用中介者的群发通知方法(此方法遍历内部容器所有交互者,对其发出通知;如果一对一类似,不过要有唯一标示识别的样子);

以此模式,如论规模多大,对于每一个交互者,都只要对中介者进行操作即可与所有(中介者中存在)的交互者交互了。而,中介者则要保存每一个交互者对象,及 交互者之间的各种交互事件的定义。(为星状拓扑结构)

(只有在关系复杂到网状结构时才使用此模式来装换为星状结构)


2016年4月  丫丫的 图片真麻烦 上传着


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

类型:行为类模式

类图:


使用情景:

  • 一般来说,只有对于那种同事类之间是网状结构的关系,才会考虑使用中介者模式。可以将网状结构变为星状结构,使同事类之间的关系变的清晰一些。
  • 对于大多数的情况,同事类之间的关系不会复杂到混乱不堪的网状结构,因此,大多数情况下,将对象间的依赖关系封装的同事类内部就可以的,没有必要非引入中介者模式。滥用中介者模式,只会让事情变的更复杂。

中介者模式的结构

中介者模式又称为调停者模式,从类图中看,共分为3部分:

  • 抽象中介者:定义好同事类对象到中介者对象的接口,用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法,并由子类去实现。
  • 中介者实现类:从抽象中介者继承而来,实现抽象中介者中定义的事件方法。从一个同事类接收消息,然后通过消息影响其他同时类。
  • 同事类:如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对象称为同事类。在类图中,同事类只有一个,这其实是现实的省略,在实际应用中,同事类一般由多个组成,他们之间相互影响,相互依赖。同事类越多,关系越复杂。并且,同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中,同事类之间必须通过中介者才能进行消息传递

模式图


这是一个copy的例子:(我觉得使用容器保存同事对象会好些)

我们使用一个例子来说明一下什么是同事类:有两个类A和B,类中各有一个数字,并且要保证类B中的数字永远是类A中数字的100倍。也就是说,当修改类A的数时,将这个数字乘以100赋给类B,而修改类B时,要将数除以100赋给类A。类A类B互相影响,就称为同事类。代码如下:


abstract class AbstractColleague {

	protected int number;

 

	public int getNumber() {

		return number;

	}

 

	public void setNumber(int number){

		this.number = number;

	}

	//抽象方法,修改数字时同时修改关联对象

	public abstract void setNumber(int number, AbstractColleague coll);

}

 

class ColleagueA extends AbstractColleague{

	public void setNumber(int number, AbstractColleague coll) {

		this.number = number;

		coll.setNumber(number*100);

	}

}

 

class ColleagueB extends AbstractColleague{

	

	public void setNumber(int number, AbstractColleague coll) {

		this.number = number;

		coll.setNumber(number/100);

	}

}

 

public class Client {

	public static void main(String[] args){

 

		AbstractColleague collA = new ColleagueA();

		AbstractColleague collB = new ColleagueB();

		

		System.out.println("==========设置A影响B==========");

		collA.setNumber(1288, collB);

		System.out.println("collA的number值:"+collA.getNumber());

		System.out.println("collB的number值:"+collB.getNumber());

 

		System.out.println("==========设置B影响A==========");

		collB.setNumber(87635, collA);

		System.out.println("collB的number值:"+collB.getNumber());

		System.out.println("collA的number值:"+collA.getNumber());

	}

}

上面的代码中,类A类B通过直接的关联发生关系,假如我们要使用中介者模式,类A类B之间则不可以直接关联,他们之间必须要通过一个中介者来达到关联的目的。


abstract class AbstractColleague {

	protected int number;

 

	public int getNumber() {

		return number;

	}

 

	public void setNumber(int number){

		this.number = number;

	}

	//注意这里的参数不再是同事类,而是一个中介者

	public abstract void setNumber(int number, AbstractMediator am);

}

 

class ColleagueA extends AbstractColleague{

 

	public void setNumber(int number, AbstractMediator am) {

		this.number = number;

		am.AaffectB();

	}

}

 

class ColleagueB extends AbstractColleague{

 

	@Override

	public void setNumber(int number, AbstractMediator am) {

		this.number = number;

		am.BaffectA();

	}

}

 

abstract class AbstractMediator {

	protected AbstractColleague A;

	protected AbstractColleague B;

	

	public AbstractMediator(AbstractColleague a, AbstractColleague b) {

		A = a;

		B = b;

	}

 

	public abstract void AaffectB();

	

	public abstract void BaffectA();

 

}

class Mediator extends AbstractMediator {

 

	public Mediator(AbstractColleague a, AbstractColleague b) {

		super(a, b);

	}

 

	//处理A对B的影响

	public void AaffectB() {

		int number = A.getNumber();

		B.setNumber(number*100);

	}

 

	//处理B对A的影响

	public void BaffectA() {

		int number = B.getNumber();

		A.setNumber(number/100);

	}

}

 

public class Client {

	public static void main(String[] args){

		AbstractColleague collA = new ColleagueA();

		AbstractColleague collB = new ColleagueB();

		

		AbstractMediator am = new Mediator(collA, collB);

		

		System.out.println("==========通过设置A影响B==========");

		collA.setNumber(1000, am);

		System.out.println("collA的number值为:"+collA.getNumber());

		System.out.println("collB的number值为A的10倍:"+collB.getNumber());

 

		System.out.println("==========通过设置B影响A==========");

		collB.setNumber(1000, am);

		System.out.println("collB的number值为:"+collB.getNumber());

		System.out.println("collA的number值为B的0.1倍:"+collA.getNumber());

		

	}

}
时间: 2024-11-09 01:52:40

设计模式笔记:中介者模式的相关文章

设计模式 笔记 中介者模式 Mediator

//---------------------------15/04/27---------------------------- //Mediator 中介者模式----对象行为型模式 /* 1:意图: 用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显式地相互引用,从而使其耦合松散, 而且可以独立地改变它们之间的交互. 2:动机: 3:适用性: 1>一组对象以定义良好但是复杂的方式进行通信.产生的相互依赖关系结构混乱且难以理解. 2>一个对象引用其他很多对象并且直接与这些对象通信

设计模式之中介者模式(Mediator)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

设计模式之中介者模式20170731

行为型设计模式之中介者模式: 一.含义 用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 同事角色与其他同时角色通信的时候,一定要通过中介者角色(中介者封装了各个同事类之间的逻辑关系) 二.代码说明 1.主要有两个角色 1)中介者角色 通过协调各同事角色实现协作行为,因此它必须依赖于各个同事角色. 2)同事角色 每一个同事角色都知道中介者角色,而且与其他的同事角色通信的时候,一定要通过中介者角色协作. 每个同事类的行为分

设计模式(中介者模式-对象去耦)

声明:本系列文章内容摘自<iOS设计模式> 中介者模式 用一个对象来封装一系列对象的交互方式.中介者使个对象不需要显式地相互调用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 何时使用中介者模式 1.对象间的交互虽定义明确然而非常复杂,导致椅子对象彼此相互依赖而且难以理解: 2.因为对象引用了许多其他对象并与其通信,导致对象难以复用: 3.想要制定一个分布在多个对象中的逻辑或行为,又不想生成太多子类. 举个例子 有三个视图,我们可能需要两两之间进行跳转,类比于公司内同时每两个人都有可能

【设计模式】——中介者模式

中介者模式(Mediator),用一个中介者对象来封装一系列的对象交互.中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互. Colleague叫做抽象同事类,而ConcreteColleague是具体同事类,每个具体同事只知道自己的行为,而不了解其他同事类的情况,但它们却都认识中介者对象,Mediator是抽象中介者,定义了同事对象到中介者对象的接口,ConcreteMediator是具体中介者对象,实现抽象类的方法,它需要知道所有具体同事类,并从具体同事接

折腾Java设计模式之中介者模式

博文原址:折腾Java设计模式之中介者模式 中介者模式 中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性.这种模式提供了一个中介类,该类通常处理不同类之间的通信,并支持松耦合,使代码易于维护.中介者模式属于行为型模式. 通俗点来讲就是提供一个中介平台,说到平台,那其实很容易联系到我们很熟悉的房地产中介.我们可以直接通过这个平台得到我们想要的信息,不用对象自身与其他对象交互. 买房子租房子就不需要去找房东,只需要在中介那里获取相应的×××信息.如下图那样,两方只

大话设计模式笔记 职责链模式 中介者模式

职责链模式(Chain of Responsibility):使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. 优点:当客户提交一个请求是,请求是沿链传递直至有一个ConcreteHandler对象负责处理它. 接收者和发送者都没有对方的明确信息,且链中的对象自己也并不知道链的结构.结果是职责链可以简化对象的相互连接. 中介者模式(Mediator),用一个中介对象来封装一系列的对象交互.中介者使各对

设计模式之: 中介者模式

一.前言 平常我们写一个聊天软件,如果我们只是各个客户端之间连接聊天,那估计我们会写的想哭,那如果我们用服务器作为中间媒介,通过服务器来完成转发,群聊等客户端之间的连接,那样我们就可以最大程度的为各个客户端之间解耦,把它们之间的通信方法抽出来单独实现, 如图1就是不使用中介媒体的时候的结构图: 如图2就是使用我们所说的服务器作为中间媒介的情况的结构图: 二.中介模式 图二就是我们所说的中介模式! 在GOF的<设计模式:可复用面向对象软件的基础>一书中对中介者模式是这样说的:用一个中介对象来封装

大话设计模式_中介者模式(Java代码)

中介者模式:用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显示的相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 简单描述:1个抽象Colleague,其派生多个具体ConcreteColleague,每个具体ConcreteColleague都认识一个具体中介者.他们发送消息的时候是通过中介者发送.1个中介者,具体中介者认识所有的ConcreteColleague(即持有所有具体ConcreteColleague的引用),它提供向其他具体ConcreteColleag

Java 设计模式之中介者模式

本文继续23种设计模式系列之中介者模式. 定义 用一个中介者对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使耦合松散,而且可以独立地改变它们之间的交互. 角色 抽象中介者:定义好同事类对象到中介者对象的接口,用于各个同事类之间的通信.一般包括一个或几个抽象的事件方法,并由子类去实现. 中介者实现类:从抽象中介者继承而来,实现抽象中介者中定义的事件方法.从一个同事类接收消息,然后通过消息影响其他同时类. 同事类:如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对