设计模式_中介者模式(25)

• 什么是中介者模式
• 中介者模式的例子
• 中介者模式的优缺点
• 中介者模式的使用场景
• 闲言碎语

什么是中介者模式

  出门在外,租房子是我们这些刚刚踏出大学门的学生必须面对的问题.这时,对于大部分没有关系没有人脉的我们,找中介是我们最好的选择.同样在编程中我们也会遇到可能不希望多个对象进行显性交互的情况.这时我们就需要用到中介者模式了.

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

  角色: 

    1.Mediator:中介者定义一个接口用于与各同事（Colleague）对象通信。

    2.ConcreteMediator:具体中介者通过协调各同事对象实现协作行为，了解并维护它的各个同事。

    3.User:抽象客户类。

    4.Renter/landLord:具体同事类。每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中

  UML:

  

中介者模式的例子

中介部分的接口

package com.designPattern.mediator6;

/**
 * 中介模式的接口
 * 
 * @author jason
 *
 */
public interface Mediator {
	public void declare(User user, String message);
}

用户的接口

package com.designPattern.mediator6;

/**
 * 用户的抽象
 * 
 * @author jason
 *
 */
public abstract class User {
	Mediator mediator;

	/**
	 * 确保每个用户拥有一个中介对象
	 * 
	 * @param mediator
	 */
	public User(Mediator mediator) {
		this.mediator = mediator;
	}

	/**
	 * 发送消息
	 * 
	 * @param message
	 */
	public abstract void sendMessage(String message);

	/**
	 * 接受消息
	 * 
	 * @param message
	 */
	public abstract void acceptMessage(String message);

}

具体的中介

package com.designPattern.mediator6;

/**
 * 具体的中介结构
 * 
 * @author jason
 *
 */
public class LianJiaMediator implements Mediator {
	private LandLord landLord;
	private Renter renter;

	/**
	 * FIXME 待优化,如果有多个user用户通用mediator必然会造成代码臃肿!
	 */
	@Override
	public void declare(User dis, String message) {
		if (dis instanceof LandLord) {
			renter.acceptMessage(message);
		} else {
			landLord.acceptMessage(message);
		}
	}

	public LandLord getLandLord() {
		return landLord;
	}

	public void setLandLord(LandLord landLord) {
		this.landLord = landLord;
	}

	public Renter getRenter() {
		return renter;
	}

	public void setRenter(Renter renter) {
		this.renter = renter;
	}

}

房东

package com.designPattern.mediator6;

/**
 * 具体房东
 * 
 * @author jason
 *
 */
public class LandLord extends User {
	private String name;

	// 构造函数
	public LandLord(Mediator mediator, String name) {
		super(mediator);
		this.name = name;
	}

	@Override
	public void sendMessage(String message) {
		mediator.declare(this, message);
	}

	@Override
	public void acceptMessage(String message) {
		System.out.println(name + "收到消息:" + message);
	}

	public String getName() {
		return name;
	}

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

}

租客

package com.designPattern.mediator6;

/**
 * 具体租客
 * 
 * @author jason
 *
 */
public class Renter extends User {
	private String name;

	public Renter(Mediator mediator, String name) {
		super(mediator);
		this.name = name;
	}

	@Override
	public void sendMessage(String message) {
		mediator.declare(this, message);
	}

	@Override
	public void acceptMessage(String message) {
		System.out.println(name + "收到消息:" + message);

	}

	public String getName() {
		return name;
	}

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

}

测试类

package com.designPattern.mediator6;

import org.junit.Test;

/**
 * 测试类
 * 
 * @author jason
 *
 */
public class TestCase {

	@Test
	public void test() {
		LianJiaMediator mediator = new LianJiaMediator();
		LandLord landLord = new LandLord(mediator, "房东");
		Renter renter = new Renter(mediator, "租客");
		mediator.setLandLord(landLord);
		mediator.setRenter(renter);
		renter.sendMessage("有房子出租吗?");
		landLord.sendMessage("有很多空的房子!");
	}
}

中介者模式的优缺点

 优点：

  （1）松散耦合，消除了对象之间的耦合；

  （2）集中控制交互，对象之间的交互都被封装到中介者对象中，如果交互发生变化，只需要修改中介者对象就可以了；

  （3）将多对多的关系变成一对多，让对象关系更加清晰，容易实现，其实还是解耦。

 缺点：

   多度集中化，如果对象之间的交互比较多且比较复杂，中介者在封装这些交互时也会变得更加复杂，而且难于管理和维护。

中介者模式的使用场景 

  (1)如果一组对象之间交互复杂,导致相互依赖,结构混乱,可以采用中介模式
  (2）如果一个类引用很多类，并直接跟这些类交互，导致难以复用该类，可以采用中介者模式，把这个类跟其他类的交互封装到中介者里面，这样该类就只需跟中介者交互了

闲言碎语

  无