前两天,班长在微信群里通知,马上就是毕业十周年了,准备组织一个母校的十周年同学聚会。届时,许多多年不联系的同学都在群里活跃了起来,大家纷纷回想大学的美好时光,历历在目,仿若昨天。想起初中时,没有微信,没有QQ,暑假期间老师给大家布置任务,只能让某个同学一对一地通知,然后一对一地回复。大概情景是这样的:
一个班级有50多个同学,如果把这个50多个同学都放到这个通信网状结构上,那就是真真的“蜘蛛网”了,一个消息反复通知不说。原本把一个系统分割成一些对象是可以增强复用性的,但是现在的情况是,这些兑现之间存在着大量的联系,耦合性极高。这是很不利于复用的,同时这种情况使得系统的灵活性大大的降低,使得对系统的扩展很难,要是新转来一个学生的话,要改动的地方就多了去了。代码如下:
package com.pattern.mediator.v1;
public abstract class AbstractClassmate {
protected String name;
protected String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public AbstractClassmate(String name) {
this.name = name;
}
public String getName() {
return name;
}
public abstract void sendMessage(String message,AbstractClassmate mate);
}
package com.pattern.mediator.v1;
public class ClassmateA extends AbstractClassmate {
public ClassmateA(String name) {
super(name);
}
@Override
public void sendMessage(String message, AbstractClassmate mate) {
this.message=message;
mate.setMessage(message);
System.out.println(this.getName()+"通知"+mate.getName()+":"+message);
}
}
package com.pattern.mediator.v1;
public class ClassmateB extends AbstractClassmate {
public ClassmateB(String name) {
super(name);
}
@Override
public void sendMessage(String message, AbstractClassmate mate) {
this.message=message;
mate.setMessage(message);
System.out.println(this.getName()+"通知"+mate.getName()+":"+message);
}
}
package com.pattern.mediator.v1;
public class ClassmateC extends AbstractClassmate {
public ClassmateC(String name) {
super(name);
}
@Override
public void sendMessage(String message, AbstractClassmate mate) {
this.message=message;
mate.setMessage(message);
System.out.println(this.getName()+"通知"+mate.getName()+":"+message);
}
}
package com.pattern.mediator.v1;
public class Client {
public static void main(String[] args){
AbstractClassmate mateA=new ClassmateA("小军");
AbstractClassmate mateB=new ClassmateB("小红");
AbstractClassmate mateC=new ClassmateC("小新");
mateA.sendMessage("10月8号到母校参加同学10周年聚会呀!", mateB);
mateB.sendMessage("好的,收到!", mateA);
mateA.sendMessage("10月8号到母校参加同学10周年聚会呀!", mateC);
mateC.sendMessage("不好意思,我有事去不了!", mateB);
}
}
测试结果:
如果引入中介者模式,那么同学类之间的通信关系将变为星型结构,从图中可以看到,任何一个类的变动,只会影响的类本身,以及中介者,这样就减小了系统的耦合。一个好的设计,必定不会把所有的对象关系处理逻辑封装在本类中,而是使用一个专门的类来管理那些不属于自己的行为。
那么,什么是中介者模式呢?
中介者模式(Mediator Pattern):用一个中介者对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使耦合松散,而且可以独立地改变它们之间的交互。
中介者模式又称为调停者模式,共分为3部分:
抽象中介者:定义好同事类对象到中介者对象的接口,用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法,并由子类去实现。
中介者实现类:从抽象中介者继承而来,实现抽象中介者中定义的事件方法。从一个同事类接收消息,然后通过消息影响其他同时类
同事类:如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对象称为同事类。在类图中,同事类只有一个,这其实是现实的省略,在实际应用中,同事类一般由多个组成,他们之间相互影响,相互依赖。同事类越多,关系越复杂。并且,同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中,同事类之间必须通过中介者才能进行消息传递。
再说说同学聚会的事儿,现在班长借助“微信”这个中介者,只需要在群里发出消息,大家就能收到消息。再各自发出自己的回复,班长和其他同学都能收到回复。代码如下:
package com.pattern.mediator.v2;
/**
* 中介者抽象类
* @author Jerify
*
*/
public abstract class AbstractMediator {
public abstract void sendMessage(String message,AbstractClassmate mate);//给同学发送消息
}
package com.pattern.mediator.v2;
import java.util.ArrayList;
import java.util.List;
public class Mediator extends AbstractMediator {
protected List<AbstractClassmate> matelist=new ArrayList<AbstractClassmate>();
public void addClassmate(AbstractClassmate mateA){
matelist.add(mateA);
}
@Override
public void sendMessage(String message, AbstractClassmate mate) {
System.out.println("同学"+mate.getName()+"说:"+message);
for(AbstractClassmate mateX:matelist){//中介将消息广播给其他同学,在此模拟通知
if(!mate.getName().equals(mateX.getName())){
System.out.println("----------中介者通知"+mateX.getName()+"-------"+mate.getName()+"说:"+message);
}
}
}
}
package com.pattern.mediator.v2;
/**
* 同学抽象类
* @author Jerify
*
*/
public abstract class AbstractClassmate {
protected String name;
protected String message;
protected AbstractMediator mediator;
public AbstractClassmate(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public AbstractMediator getMediator() {
return mediator;
}
public void setMediator(AbstractMediator mediator) {
this.mediator = mediator;
}
public abstract void sendMessage(String message,AbstractMediator mediator);//发送消息
}
package com.pattern.mediator.v2;
public class ClassmateA extends AbstractClassmate{
public ClassmateA(String name) {
super(name);
}
@Override
public void sendMessage(String message, AbstractMediator mediator) {//同学发送消息给中介者,中介者再将消息广播给其他同学
this.message=message;
this.mediator=mediator;
this.mediator.sendMessage(message, this);
}
}
package com.pattern.mediator.v2;
public class ClassmateB extends AbstractClassmate{
public ClassmateB(String name) {
super(name);
}
@Override
public void sendMessage(String message, AbstractMediator mediator) {//同学发送消息给中介者,中介者再将消息广播给其他同学
this.message=message;
this.mediator=mediator;
this.mediator.sendMessage(message, this);
}
}
package com.pattern.mediator.v2;
public class ClassmateC extends AbstractClassmate{
public ClassmateC(String name) {
super(name);
}
@Override
public void sendMessage(String message, AbstractMediator mediator) {//同学发送消息给中介者,中介者再将消息广播给其他同学
this.message=message;
this.mediator=mediator;
this.mediator.sendMessage(message, this);
}
}
客户端测试:
package com.pattern.mediator.v2;
/**
* 客户端测试类
* @author Jerify
*
*/
public class Client {
public static void main(String[] args) {
Mediator mediator=new Mediator();//中介者
AbstractClassmate mateA=new ClassmateA("小军");
AbstractClassmate mateB=new ClassmateB("小红");
AbstractClassmate mateC=new ClassmateC("小新");
mediator.addClassmate(mateA);
mediator.addClassmate(mateB);
mediator.addClassmate(mateC);
mateA.sendMessage("10月8号到母校参加同学10周年聚会呀!收到请回复。", mediator);//同学A跟中介说者
mateB.sendMessage("好的,收到!", mediator);//同学B告诉中介者
mateC.sendMessage("不好意思,我有事去不了!", mediator);//同学C告诉中介者
}
}
测试结果:
使用中介者模式的优点:
1.降低了系统对象之间的耦合性,使得对象易于独立的被复用。
2.提高系统的灵活性,使得系统易于扩展和维护。
使用中介者模式的缺点:
中介者模式的缺点是显而易见的,因为这个“中介“承担了较多的责任,所以一旦这个中介对象出现了问题,那么整个系统就会受到重大的影响。
源码下载:http://download.csdn.net/download/pelifymeng2/9994744