Java设计模式--中介者模式【Mediator Pattern】

        前两天,班长在微信群里通知,马上就是毕业十周年了,准备组织一个母校的十周年同学聚会。届时,许多多年不联系的同学都在群里活跃了起来,大家纷纷回想大学的美好时光,历历在目,仿若昨天。想起初中时,没有微信,没有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




  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值