设计模式之-----中介者模式

今天学习中介者模式，话说都快学完了，很快啊，还有最后几个，加油啊！！

所谓中介者模式，一看名字就明白了，我们在外生活，免不了与各种中介打交道，比如在外工作需要租房子，我们人生地不熟的，不可能一下子就找到合适的房子，那么这个时候我们就需要中介来帮忙了，我只需要告诉中介我们需要什么样的房子，剩下的就不用我们管了，中介会按照我们的标准去联系在他这里注册过的房东，如果有符合要求的，那么用户与房东签协议，交钱，然后就ok了。在整个过程中，租户不需要与房东直接发生正面联系，我们的一切信息都是在中介那里获得的。把这个概念带入到代码里，就可以在很大程度上对两个对象解耦。

通过迪米特法则我们可以知道，我们的类要尽量不要直接和其他类进行通信，必要的时候，我们可以借助第三方来实现这个通信。这个时候，中介就是这个第三方。

取用网上的一段话： 通过中介者模式，我们可以将复杂关系的网状结构变成结构简单的以中介者为核心的星形结构，每个对象不再和它与之关联的对象直接发生相互作用，而是通过中介者对象来另一个对象发生相互作用。

好，现在我们来点干货，当然就是你如何实现了，我们就用上边的例子。先看包结构

首先是中介者的抽象类

package com.mediator.abs.mediator;

import com.mediator.abs.colleague.Person;

/**
 * 抽象中介者
 * @author ZHENGWEI
 * @date 2015-8-12
 */
public abstract class Mediator {

	/**
	 * 中介者传话的方法
	 * @param message
	 * @param person
	 */
	public abstract void passMessage(String message, Person person);
}

之后是租户和房东共同的抽象方法

package com.mediator.abs.colleague;

import com.mediator.abs.mediator.Mediator;

/**
 * 租房者或者房东的抽象类
 * @author ZHENGWEI
 * @date 2015-8-12
 */
public abstract class Person {

	protected Mediator mediator;
	
	public Person(Mediator mediator){
		this.mediator = mediator;
	}
}

然后就是房东和租户的具体实现

package com.mediator.concrete.colleague;

import com.mediator.abs.colleague.Person;
import com.mediator.abs.mediator.Mediator;

/**
 * 房东的具体实现类
 * @author ZHENGWEI
 * @date 2015-8-12
 */
public class FangDong extends Person {

	public FangDong(Mediator mediator) {
		super(mediator);
	}
	
	/**
	 * 房东只需要把信息告诉中介即可，其他的不需要管
	 * @param message
	 */
	public void sendMessageToMediator(String message){
		this.mediator.passMessage(message, this);
	}
	
	/**
	 * 房东只从中介那里接收消息，具体消息来源他不需要关心
	 * @param message
	 */
	public void getMessageForMediator(String message){
		System.out.println("房东收到消息："+message);
	}

}

package com.mediator.concrete.colleague;

import com.mediator.abs.colleague.Person;
import com.mediator.abs.mediator.Mediator;

/**
 * 租户的具体实现类
 * @author ZHENGWEI
 * @date 2015-8-12
 */
public class ZuHu extends Person {

	public ZuHu(Mediator mediator) {
		super(mediator);
	}
	
	/**
	 * 租户只需要把信息告诉中介即可，其他的不需要管
	 * @param message
	 */
	public void sendMessageToMediator(String message){
		this.mediator.passMessage(message, this);
	}
	
	/**
	 * 租户只从中介那里接收消息，具体消息来源他不需要关心
	 * @param message
	 */
	public void getMessageForMediator(String message){
		System.out.println("租户收到消息："+message);
	}

}

然后是中介的具体实现

package com.mediator.concrete.mediator;

import com.mediator.abs.colleague.Person;
import com.mediator.abs.mediator.Mediator;
import com.mediator.concrete.colleague.FangDong;
import com.mediator.concrete.colleague.ZuHu;

/**
 * 具体的租房机构，这里可以理解为“XXXX中介”
 * 
 * @author ZHENGWEI
 * @date 2015-8-12
 */
public class ZuFangJiGou extends Mediator {

	// 作为中介，肯定要实现知道租户和房东的信息
	private FangDong fangDong;
	private ZuHu zuHu;

	public FangDong getFangDong() {
		return fangDong;
	}

	public void setFangDong(FangDong fangDong) {
		this.fangDong = fangDong;
	}

	public ZuHu getZuHu() {
		return zuHu;
	}

	public void setZuHu(ZuHu zuHu) {
		this.zuHu = zuHu;
	}

	
	@Override
	public void passMessage(String message, Person person) {
		if(person.getClass().equals(FangDong.class)){
			this.zuHu.getMessageForMediator(message);
		} else if(person.getClass().equals(ZuHu.class)){
			this.fangDong.getMessageForMediator(message);
		}
	}

}

上边判断的时候是根据不同的对象做出不同的反应

最后是测试类

package com.mediator.main;

import com.mediator.concrete.colleague.FangDong;
import com.mediator.concrete.colleague.ZuHu;
import com.mediator.concrete.mediator.ZuFangJiGou;

public class MediatorMain {

	public static void main(String[] args) {
		// 先声明中介机构
		ZuFangJiGou mediator = new ZuFangJiGou();
		
		// 然后是房东和租户两个角色，这两个角色不必互相知道对方，他们只要知道中介即可
		FangDong fangDong = new FangDong(mediator);
		ZuHu zuHu = new ZuHu(mediator);
		
		// 同样的，中介也需要知道他们的信息
		mediator.setFangDong(fangDong);
		mediator.setZuHu(zuHu);
		
		zuHu.sendMessageToMediator("你那里有多出来的房间么？");
		fangDong.sendMessageToMediator("我这里有空余的房间");
	}

}

最后来看看结果

再次引用网上的一段话：

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

     通过定义我们可以看出中介者主要是通过中介对象来封装对象之间的关系，使之各个对象在不需要知道其他对象的具体信息情况下通过中介者对象来与之通信。同时通过引用中介者对象来减少系统对象之间关系，提高了对象的可复用和系统的可扩展性。

     但是就是因为中介者对象封装了对象之间的关联关系，导致中介者对象变得比较庞大，所承担的责任也比较多。它需要知道每个对象和他们之间的交互细节，如果它出问题，将会导致整个系统都会出问题。所以它比较容易应用也很容易误用。故当系统中出现了“多对多”交互复杂的关系群时，千万别急着使用中介者模式，你首先需要做的就是反思你的系统在设计上是不是合理。