设计模式之中介者模式

一、定义

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

定义的意思是：多个对象之间相互关联，从而造成关系比较复杂，而中介者的使用降低了它们之间的耦合。我们可以用一对图来说明：

4个对象的交互全部放在中介者当中。

二、举例说明

举个我们生活中的例子，就是房地产中介。其实就是个中介者模式，而购房者和房主则是对象。如果没有房地产中介的话，购房者和房主是直接交互的。房主发布卖房信息------购-------房者查看房子信息，如果喜欢房主的房子的话，联系房主-------约定看房的时间-------购房者交款------房主交房（这里我们把关系说的简单点）。期间如果买房者在约定看房的时间当天有其他事情，还得联系房主从新约定时间或者房主有其他的事情的话，还得告诉购房者从新约定时间。总之他们之间的关系耦合度很高。

如果有了房地产中介后，购房者和房主的关系就松散了。房主在中介那递交了房子资料后，就不用管了，如果房子卖出后直接收钱就行。而购房者也不用和房主直接联系了，直接和房地产中介沟通。不会存在爽约的情况。

下面是Mediator的原型类图：

三、代码说明

房主：

public class FangZhu {
	
	private Mediator mediator;
	private String name = "房姐";
	
	public FangZhu(Mediator mediator){
		this.mediator = mediator;
	}
	
	public void giveHouseMaterial(){
		System.out.println("房主交个房地产中介预售房子的资料");
		mediator.houseMaterialChanged("三室两厅120平米，房主姓名："+name);
	}
	
	public void sellHouse(){
		System.out.println(name+"移交房子");
		mediator.getFangZhuHouse();
	}
	
	public void getMoney(int money){
		System.out.println(name+"获得了"+money+"万");
		sellHouse();
	}

}

购房者：

public class GouFangZhe {

	private Mediator mediator;
	
	public GouFangZhe(Mediator mediator){
		this.mediator = mediator;
	}
	
	public String lookHouseMaterial(){
		ArrayList<String> materials = mediator.getHouseMaterials();
		for(int i=0;i<materials.size();i++){
			System.out.println("购房者浏览房子信息"+materials.get(i));
		}
		System.out.println("喜欢上了："+materials.get(1));
		return materials.get(1);
	}
	
	public void lookHouse(){
		System.out.println("和中介约好看房子");
	}
	
	public void giveMoney(){
		System.out.println("交给中介500万");
		mediator.getGouFangZheMoney(500);
	}
	
	public void getHouse(){
		System.out.println("购房者获得房子");
	}
}

房地产中介者：

public class Mediator {

	private ArrayList<String> houseMaterials = new ArrayList<String>();

	public Mediator() {
		houseMaterials.add("一室一厅36平米，房主姓名:房叔");
	}

	FangZhu fangZhu;
	GouFangZhe gouFangZhe;

	public FangZhu getFangZhu() {
		return fangZhu;
	}

	public void setFangZhu(FangZhu fangZhu) {
		this.fangZhu = fangZhu;
	}

	public GouFangZhe getGouFangZhe() {
		return gouFangZhe;
	}

	public void setGouFangZhe(GouFangZhe gouFangZhe) {
		this.gouFangZhe = gouFangZhe;
	}

	/**
	 * 有新房源的资料了
	 * 
	 * @param houseMaterial
	 */
	public void houseMaterialChanged(String houseMaterial) {
		houseMaterials.add(houseMaterial);
		String likedHouse = gouFangZhe.lookHouseMaterial();
		gouFangZhe.lookHouse();
		gouFangZhe.giveMoney();
	}

	/**
	 * 获得房主的钱
	 * 
	 * @param money
	 */
	public void getGouFangZheMoney(int money) {
		fangZhu.getMoney(money);
	}

	/**
	 * 获得房主的房子
	 */
	public void getFangZhuHouse() {
		gouFangZhe.getHouse();
		houseMaterials.remove(1);
	}

	public ArrayList<String> getHouseMaterials() {
		return houseMaterials;
	}

	public void setHouseMaterials(ArrayList<String> houseMaterials) {
		this.houseMaterials = houseMaterials;
	}

}

Client端：

public class Client {
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Mediator mediator = new Mediator();
		FangZhu fangZhu = new FangZhu(mediator);
		GouFangZhe gouFangZhe = new GouFangZhe(mediator);
		mediator.setFangZhu(fangZhu);
		mediator.setGouFangZhe(gouFangZhe);
		
		fangZhu.giveHouseMaterial();
	}

}

执行结果：

四、总结

功能：中介者的功能非常的简单，就是封装对象之间的交互。

优点：

         1】松散耦合

         2】集中控制交互

         3】多对多变成了一对多

缺点：

         过度的集中化。如果交互的对象过多的话，而且比较复杂，当这些复杂性全部集中到中介者的时候，会导致中介者对象变的十分的复杂，而且难于管理和维护。