中介者模式

定义：

       定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者又叫调停模式，它是迪米特法则的典型应用。

适用场景：

       1、当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。

       2、当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

优点：

       1、降低了对象之间的耦合性，使得对象易于独立地被复用。

       2、将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

缺点：

       1、当同事类太多时，中介者的职责将很大，它会变得复杂和庞大，以至于系统难以维护。

组成元素：

       1、抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。

       2、具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个List来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。

       3：抽象同事（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。

       4、具体同事类（ConcreteColleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

类图如下：

抽象代码实现：

       1、定义抽象中介者Mediator：

public interface Mediator {

	public void register(Colleague colleague);
	
	public void relay(Colleague colleague);
}

       2、定义具体中介者ConcreteMediator：

public class ConcreteMediator implements Mediator{

	private List<Colleague> colleagueList = new ArrayList<Colleague>();

	@Override
	public void register(Colleague colleague) {
		if(!colleagueList.contains(colleague)){
			colleagueList.add(colleague);
			colleague.setMediator(this);
		}
	}
	
	/*当有同事发出请求时，其他的同事可以接收到请求*/
	@Override
	public void relay(Colleague colleague) {
		for(Colleague ob:colleagueList){
			if(!ob.equals(colleague)){
				((Colleague)ob).receive();
			}   
		}
	}
}

       3、定义抽象同事Colleague：

public  abstract class Colleague {

	public  Mediator mediator;
	
	public abstract void receive();
	
	public abstract void send();

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

       4、定义具体同事类ConcreteColleagueA和ConcreteColleagueB：

public class ConcreteColleagueA extends Colleague{

	@Override
	public void receive() {
	    System.out.println("具体同事类A收到请求。");
	}

	@Override
	public void send() {
	    System.out.println("具体同事类A发出请求。");
	    /*请中介者转发*/
	    mediator.relay(this); 
	}
}

public class ConcreteColleagueB extends Colleague{

	@Override
	public void receive() {
	    System.out.println("具体同事类B收到请求。");
	}

	@Override
	public void send() {
	    System.out.println("具体同事类B发出请求。");
	    /*请中介者转发*/
	    mediator.relay(this); 
	}
}

       5、测试代码如下：

public class TestMain {

	public static void main(String[] args) {
		Mediator md=new ConcreteMediator();
		Colleague c1=new ConcreteColleagueA();
		Colleague c2=new ConcreteColleagueB();

		md.register(c1);
		md.register(c2);

		c1.send();
		System.out.println("-------------");
		c2.send();
	}
}

       6、输出结果如下：

示例代码实现：

      作为一名标准的90后，现在的聊天工具基本上都是微信，我们通过微信来进行相互沟通，其实也可以看作是中介者模式，微信相当于中介者，我们通过它进行信息的传递，接下来我们使用中介者模式来实现这一个过程。

      1、定义抽象中介者Mediator：

public interface Mediator {

	public void register(User user);
	
	public void relay(User user,String message);
}

      2、定义具体中介者WechatMediator：

public class WechatMediator implements Mediator{

	private List<User> userList = new ArrayList<User>();

	@Override
	public void register(User user) {
		if(!userList.contains(user)){
			userList.add(user);
			user.setMediator(this);
		}
	}
	@Override
	public void relay(User user,String message) {
		for(User u:userList){
			if(!u.equals(user)){
				((User)u).receive(message);
			}   
		}
	}
}

       3、定义抽象用户类User：

public  abstract class User {

	public  Mediator mediator;
	
	public abstract void receive(String message);
	
	public abstract void send(String message);

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

       4、定义具体用户类ConcreteUserA和ConcreteUserB：

public class ConcreteUserA extends User{

	@Override
	public void receive(String message) {
		System.out.println("张三收到的消息为："+message);
	}

	@Override
	public void send(String message) {
		System.out.println("张三发出的消息为："+message);
		/*请中介者转发*/
		mediator.relay(this,message); 
	}
}

public class ConcreteUserB extends User{

	@Override
	public void receive(String message) {
		System.out.println("李四收到的消息为："+message);
	}

	@Override
	public void send(String message) {
		System.out.println("李四发出的消息为："+message);
		/*请中介者转发*/
		mediator.relay(this,message); 
	}
}

       5、测试代码如下：

public class TestMain {

	public static void main(String[] args) {
		Mediator md=new WechatMediator();
		User c1=new ConcreteUserA();
		User c2=new ConcreteUserB();

		md.register(c1);
		md.register(c2);

		c1.send("我喜欢你很久了");
		System.out.println("-------------");
		c2.send("我也是");
	}
}

       6、输出结果如下：

 框架代码实战：

       1、在 MVC 框架中，控制器（C）就是模型（M）和视图（V）的中介者；