调停者模式

首先，调停者模式相当与各个组织之间的一种独立出来的组织，为了让我们更加好的处理复杂的逻辑关系，解开各个组织之间的耦合。
uml图如下

举一个例子：比如一个公司有人事部，财务部，技术部，营销部，比如说人事部想要处理一件事情，它去找财务部，财务部又让你去找技术部，但是生产技术部又让你去找营销部，最后经历了很多流程才完成了一件事情，这个时候如果又一个中间的调停者，你把这件事情交给他，那么它就可以帮你去做剩下的事情，那该多好。
代码如下：
调停者的父类接口：

//调停者的接口
public interface Mediator {
	public void change(Department department);//代表有部门想你委托了任务请求你去帮他做后续的处理
}

调停者实现类：

public class ConcreteMediator implements Mediator{
	//人事部
	private Department Personnel;
	
	//财务部
	private Department FinanceDepartment;
	
	//生产技术部
	private Department TechnologyDepartment;
	
	//营销部
	private Department MarketingDepartment;


	@Override
	public void change(Department department) {
		if(department instanceof Personnel){//人事部的处理 
			department=(Personnel)department;
			this.FinanceDepartment.DealWithThings();//处理完交给财务部
		}else if(department instanceof FinanceDepartment){//财务部的处理
			department=(FinanceDepartment)department;
			this.TechnologyDepartment.DealWithThings();//交给技术部和营销部共同处理
			this.MarketingDepartment.DealWithThings();
		}
	}
	
	//setter getter方法我就省略了

}

部门的接口以及他们的实现子类：

//所有部门的抽象父类
public abstract class Department {
	Mediator mediator;
	
	public Department(Mediator mediator){
		this.mediator=mediator;
	}

	public Mediator getMediator() {
		return this.mediator;
	}
	
	//需要做的事情
	public abstract void DealWithThings();
	
}
======================================================================================
//人事部
public class Personnel extends Department{

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

	@Override
	public void DealWithThings() {
		System.out.println("处理人事相关的事情");
		mediator.change(this);//表明自己已经处理完毕  向调停者报告 并且让他做后续处理
	}

}
=======================================================================================
//财务部
public class FinanceDepartment extends Department{

	public FinanceDepartment(Mediator mediator) {
		super(mediator);
	}
	@Override
	public void DealWithThings() {
		System.out.println("处理财务部相关的事情");
		mediator.change(this);//表明自己已经处理完毕  向调停者报告 并且让他做后续处理
	}
}
=======================================================================================
//营销部
public class MarketingDepartment extends Department{

	public MarketingDepartment(Mediator mediator) {
		super(mediator);
	}
	@Override
	public void DealWithThings() {
		System.out.println("处理营销部相关的事情");
		mediator.change(this);//表明自己已经处理完毕  向调停者报告 并且让他做后续处理
	}
}
========================================================================================
//生产技术部
public class TechnologyDepartment extends Department{

	public TechnologyDepartment(Mediator mediator) {
		super(mediator);
	}
	@Override
	public void DealWithThings() {
		System.out.println("处理生产技术部相关的事情");
		mediator.change(this);//表明自己已经处理完毕  向调停者报告 并且让他做后续处理
	}
}

最后是我们的main方法以及它的实现结果：

public class Main {
	public static void main(String[] args){
		ConcreteMediator mediator=new ConcreteMediator();//创建调停者
		Department personnel=new Personnel(mediator);//创建各个部门
		Department financeDepartment=new FinanceDepartment(mediator);
		Department technologyDepartment=new TechnologyDepartment(mediator);
		Department marketingDepartment=new MarketingDepartment(mediator);
		mediator.setPersonnel(personnel);
		mediator.setFinanceDepartment(financeDepartment);
		mediator.setMarketingDepartment(marketingDepartment);
		mediator.setTechnologyDepartment(technologyDepartment);
		
		//人事部处理事情
		personnel.DealWithThings();
	}
}

大家可以看到，这样的话本来是再各个部门之间相互调用方法形成一个复杂的关系网，变成了一个简单的委托，由我们的调停者来进行处理，实现了各个部门之间的解耦操作，同时以后我们写代码的时候哪些复杂的操作相互调用也可以很好的解决。