中介者模式

1.中介者模式是什么

1.百度百科

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

2.维基百科

In software engineering, the mediator pattern defines an object that encapsulates how a set of objects interact. This pattern is considered to be a behavioral pattern due to the way it can alter the program's running behavior.
Usually a program is made up of a large number of classes. Logic and computation are distributed among these classes. However, as more classes are added to a program, especially during maintenance and/or refactoring, the problem of communication between these classes may become more complex. This makes the program harder to read and maintain. Furthermore, it can become difficult to change the program, since any change may affect code in several other classes.
With the mediator pattern, communication between objects is encapsulated within a mediator object. Objects no longer communicate directly with each other, but instead communicate through the mediator. This reduces the dependencies between communicating objects, thereby reducing coupling.

3.lz理解

将一堆杂乱无章类的相互调用通过一个中介对象管理起来的模式。使得调用双方只需依赖中介即可完成调用。解除了调用者和被调用者之间的耦合。

4.核心角色

抽象中介者角色 （Mediator） 抽象中介者角色定义统一的接口，用于各同事角色之间的通信。

具体中介者角色 （Concrete Mediator） 具体中介者角色，通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。

抽象事角色 （Colleague） 每一个同事角色都知道中介者角色，而且与其它的同事角色通信的时候，一定要通过中介者角色来协作。
每个同事类的行为分为二种：一种是同事本身的行为，这种行为叫做自发行为(Self-Method);第二种是必须依赖中介者才能完成的行为，叫做依赖行为(Dep-Method)。

具体同时角色（Colleagueclass） 具体同事类。每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者

2.中介者模式解决了什么问题

多个对象直接调用复杂的问题

松散耦合
　　中介者模式通过把多个同事对象之间的交互封装到调停者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。

集中控制交互
　　多个同事对象的交互，被封装在调停者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改调停者对象就可以了，当然如果是已经做好的系统，那么就扩展调停者对象，而各个同事类不需要做修改。

多对多变成一对多
　　没有使用调停者模式的时候，同事对象之间的关系通常是多对多的，引入调停者对象以后，调停者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。

3.中介者模式用法

还是业务人员和程序员的撕逼大战
业务人员、程序员、产品经理

抽象同事角色 也就是业务和程序员的父类。都能执行任务

/**
 * 抽象同时角色 依赖抽象中介者角色
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator mediator) {
		this.mediator = mediator;
	}

	/**
	 * 获得调停者对象
	 */
	public Mediator getMediator() {
		return mediator;
	}

	/**
	 * 具体行为，由子类实现
	 */
	public abstract void action();

}

具体同事角色 业务员A 程序员B

public class ConcreteColleagueA extends Colleague {

	public ConcreteColleagueA(Mediator mediator) {
		super(mediator);
	}
	//任务
	private String task = "";

	public String getTask() {
		return task;
	}

	public void setTask(String task) {
		this.task = task;
	}

	/**
	 * 示意方法，执行某些操作
	 */
	@Override
	public void action() {
		// 在需要跟其他同事通信的时候，通知调停者对象
		getMediator().colleagueChanged(this);

	}

	public void doSomething(String str) {
		System.out.println("A同事做了:" + str);
	}
}

public class ConcreteColleagueB extends Colleague {

	public ConcreteColleagueB(Mediator mediator) {
		super(mediator);
	}

	private String task = "";

	public String getTask() {
		return task;
	}

	public void setTask(String task) {
		this.task = task;
	}

	/**
	 * 示意方法，执行某些操作
	 */
	@Override
	public void action() {
		// 在需要跟其他同事通信的时候，通知调停者对象
		getMediator().colleagueChanged(this);

	}

	public void doSomething(String str) {
		System.out.println("B同事做了:" + str);
	}
}

抽象中介角色

public interface Mediator {
	//通知中介者协助任务
	void colleagueChanged(Colleague colleage);

}

具体中介者角色

public class ConcreteMediator implements Mediator {
	// 持有并维护同事A
	private ConcreteColleagueA colleagueA;
	// 持有并维护同事B
	private ConcreteColleagueB colleagueB;

	public void setColleagueA(ConcreteColleagueA colleagueA) {
		this.colleagueA = colleagueA;
	}

	public void setColleagueB(ConcreteColleagueB colleagueB) {
		this.colleagueB = colleagueB;
	}

	@Override
	public void colleagueChanged(Colleague colleage) {
		// 某一个同事类发生了变化，通常需要与其他同事交互 具体协调相应的同事对象来实现协作行为
		//将A同事的任务交给B同事完成
		if(colleage instanceof ConcreteColleagueA) {
			ConcreteColleagueA concreteColleagueA = (ConcreteColleagueA)colleage;
			colleagueB.doSomething(concreteColleagueA.getTask());
		}
		//将b同事的任务交给A同事完成
		if(colleage instanceof ConcreteColleagueB) {
			ConcreteColleagueB concreteColleagueB = (ConcreteColleagueB)colleage;
			colleagueA.doSomething(concreteColleagueB.getTask());
		}

	}

}

客户端调用

public class Customer {

	public static void main(String[] args) {
		//创建调停者
		ConcreteMediator mediator = new ConcreteMediator();

		//创建同事
		ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
		ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);

		//将同事告知调停者
		mediator.setColleagueA(colleagueA);
		mediator.setColleagueB(colleagueB);

		//同事A发起一个任务给同事b做
		colleagueA.setTask("添加一个新功能");
		colleagueA.action();

		//同事b完成任务并回馈
		colleagueB.setTask("编写需求文档");
		colleagueB.action();


	}
}

4.中介者模式的问题

中介代码复杂 中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

5.中介者模式总结

应用场景：
中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及向定制一个分布在多个类中的行为，而又不想生成太多子类的场合。

实际上中介者模式是将本来复杂混乱的调用集中到了中介者类中。当增加新的同事类时候无需修改其他同事，只需修改当前新增同事以及中介者类就能完成添加的功能。但是这也会引发一个问题当同事类变的越来越多的时候中介者将会不堪重负，其复杂性会随着同事类的增多而呈现几何级数的增加。所以只有同事类数量有限且定义良好的情况下才可以使用中介者模式，否则清慎重使用。当同事类之间互相调用关系比较稳定并且变化在同事之间提供服务的实现类不同的情况下中介者模式是一个比较好的解决方案。通俗一点将就好比找中介租房子这种需求就很稳定，有房主提供房源，有租客去租。这就比较适合中介者模式。如果租客找中介不只是租房子还要买东西、搬家、修理家具、邮寄快递等。随着租客的要求越多中介提供的服务越来越多，最后中介不堪重负，中介就失去了中介的意义。所以中介着为同事之间提供的中介服务必须是相对稳定的。