java之中介者模式

中介者模式

定义

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

角色

1. 抽象中介者(Mediator): 定义了同事对象到中介者对象之间的接口。
2. 具体中介者(ConcreteMediator): 实现抽象中介者的方法，它需要知道所有的具体同事类，同时需要从具体的同事类那里接收信息，并且向具体的同事类发送信息。
3. 抽象同事类(Colleague): 定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。
4. 具体同事类(ConcreteColleague) : 每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。

示例

抽象中介者类，保存客户信息，负责交换客户信息

public abstract class Mediator {

	private List persons;
	
	public Mediator() {
		this.persons = new ArrayList();
	}
	
	public void addPerson(Person person){
		this.persons.add(person);
	}
	
	
	
	public List getPersons() {
		return persons;
	}

	public void setPersons(List persons) {
		this.persons = persons;
	}

	public abstract void exchange(Person person,String msg);
}

中介者实现类A，将信息回调给其他有需要的客户，这里租客发消息就将消息回调给房东，反之就是房东发消息回调给租客；

public class MediatoImpl extends Mediator {
	@Override
	public void exchange(Person person, String msg) {
		for (Person person2 : this.getPersons()) {
			if(!person2.equals(person)){
				person2.getMsg(msg);
			}
		}
	}
}

客户信息，持有中介引用，例如租客要发消息给房东，则由中介转发

public abstract class Person {

	private String name;
	private Mediator mediator;
	public Person(String name, Mediator mediator) {
		super();
		this.name = name;
		this.mediator = mediator;
		mediator.addPerson(this);
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public void setMediator(Mediator mediator) {
		this.mediator = mediator;
	}

	public void sendMsg(String msg){
		this.mediator.exchange(this,msg);
	}
	public abstract void getMsg(String msg);
}

租客实现类

public class Rentor extends Person {

	public Rentor(String name, Mediator mediator) {
		super(name, mediator);
	}

	@Override
	public void getMsg(String msg) {
		// TODO Auto-generated method stub
		System.out.println(this.getName()+"收到房东信息："+msg);
	}
}

房东实现类

public class Landlord extends Person {

	public Landlord(String name, Mediator mediator) {
		super(name, mediator);
	}

	@Override
	public void getMsg(String msg) {
		// TODO Auto-generated method stub
		System.out.println(this.getName()+"收到租客信息："+msg);
	}
}

测试类

public class MediatorTest {

	public static void main(String[] args) {
		MediatoImpl mediatoImpl = new MediatoImpl();
		
		Rentor rentor = new Rentor("张三", mediatoImpl);
		Landlord landlord = new Landlord("李四", mediatoImpl);
		
		rentor.sendMsg("我想租房");
		landlord.sendMsg("我要出租");
		
	}
}

测试结果：

李四收到租客信息：我想租房
张三收到房东信息：我要出租

分析

1. 租客跟房东都持有中介的引用，当租客发送消息会调用中介的exchange方法将消息发送给房东，房东发消息同样通过中介将消息发送给租客，租客跟房东之间是松散耦合的；
2. 这个例子乍一看跟观察者模式很相似，其实不然，中介者跟主题都拥有各个客户或者观察者的引用，但是观察者强调的是一旦某个条件改变，主题会通知所有订阅的观察者；而中介则是利用一个客户的引用跟另一个客户的引用交互，客户之间松散耦合；