概述

如果一个系统中对象之间的联系呈现出网状结构，如图所示，对象之间存在大量的多对多联系，将导致系统非常复杂，这些对象既会影响别的对象，也会被别的对象所影响，这些对象称为同事对象，它们之间通过彼此的相互作用实现系统的行为。在网状结构中，几乎每个对象都需要与其他对象发生相互作用，而这种相互作用表现为一个对象与另外一个对象的直接耦合，这将导致一个过度耦合的系统。

中介者模式可以使对象之间的关系数量急剧减少，通过引入中介者对象，可以将系统的网状结构变成以中介者为中心的星性结构，如图2所示。在在这个星型结构中，同事对象不再直接与另一个对象联系，它通过中介者对象与另一个对象发生相互作用。中介者对象的存在保证了对象结构上的稳定，也就是，系统的结构不会因为新对象的引入带来大量的修改工作。

如果在一个系统中对象之间存在多对多的相互关系，可以将对象之间的一些交互行为从各个对象中分离出来，并集合封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多的关系。通过引入中介者来简化对象之间的复杂交互，中介者模式是迪米特法则的一个典型应用。

定义

中介者模式（Mediator Pattern）： 用一个中介对象（中介者）来封装一系列的对象交互，中介者模式使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间地交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

结构图

结构图

  1. Medistor（抽象中介者）：它定义一个接口，该接口用于与各同事对象之间进行通信。

  2. ConcreteMediator（抽象中介者）： 它是抽象中介者的子类，通过协调各个同事对象来实现协作行为，维持了各个同事对象的引用。

  3. Colleague（抽象同事类）：它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信

  4. ConcreteColleague（具体同事类）：它是抽象同事类的子类，每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者类来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中声明的抽象方法。

职责

中介者模式的核心在于中介者类的引入，在中介者模式中，中介者类承担了以下两方面的职责：

  1. 中转作用（结构性）。通过中介者提供的中转作用，各个同事对象就不再需要显式地引用其他同事，当需要和其他同事进行通信时，可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。

  2. 协调作用（行为性）。中介者可以更进一步地对同事之间地关系进行封装，同事可以一致地和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部地协调逻辑，对同事地请求进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持

典型代码

典型的抽象中介者类代码如下

	abstract class Mediator{
			
		protected ArrayList<Colleague> colleagues;   //用于存储同事对象

		//注册方法，用于增加同事对象
		public void register(Colleague colleague)
			colleagues.add(colleague);
		}

		//声明抽象的业务方法
		public abstract void operation();
	}

在抽象中介者中可以定义一个同事类的集合，用于存储同事对象并提供注册方法，同时声明具体中介者类所具有的方法。在具体中介者类中将实现这些抽象方法，典型的具体中介者类代码如下：

	class ConcreteMediator extends Mediator{
		//实现业务方法，封装同事之间的调用
		public void operation(){
			....
			((Colleague)(colleagues.get(0))).method1();//通过中介者调用同事类的方法
			....
		}
	}

在具体中介者类中将调用同事类的方法，调用时可以增加一些自己的业务代码对调用进行控制。

在抽象同事类中维持了一个抽象中介者的引用，用于调用中介者的方法，典型的抽象同事类代码如下：

	abstract class Colleague{
		
		protected Mediator mediator;    //维持一个抽象中介者的引用
		
		public Colleague(Mediator mediator){
			this.mediator = mediator;
		}	
		
		public abstract void method(); //声明自身的方法，处理自己的行为
		
		//定义依赖方法，与中介者进行通信
		public void method2(){
			mediator.operation();	
		}
	}

在抽象同事类中声明了同事类的抽象方法，而在具体同事类中将实现这些方法，典型的具体同事类代码如下：

	class ConcreteColleague extends Colleague{
		public ConcreteColleague (Mediator mediator){
			super(mediator);
		}
		
		//实现自身的方法
		public void method(){
		
		}
	}

在具体同事类ConcreteColleague中实现了在抽象同事类中声明的方法，其中方法method()时同事类的自身方法(Self-Method),用于处理自己的行为，而方法method2()是依赖方法（Depend-Method），用于调用在中介者中定义的方法，依赖中介者来完成相应的行为，例如调用另外一个同事类的相关方法。

代码实例

为了协调界面组件对象之间的复杂交互关系，Sunny公司开发人员使用中介者模式来设计客户信息管理窗口

结构图

结构图

Component充当抽象同事类，Button，List，ComboBox和TextBox充当具体同事类，Mediator充当抽象中介者类，ConcreteMediator充当具体中介者类，ConcreteMediator维持了对具体同事类的引用，为了简化ConcreteMediator类的代码，在其中只定义了一个Button对象和一个TextBox对象

代码实现

抽象中介者

	public abstract class Mediator {
		public abstract void componentChanged(Component c);
	}

具体中介者

	public class ConcreteMediator extends Mediator {
	
		//维持对各个同事对象的引用
		public Button addButton;
		public List list;
		public TextBox userNameTextBox;
		public ComboBox cb;
		
		//封装同事对象之间的交互
		public void componentChanged(Component c) {
			//单击按钮
			if(c == addButton) {
				System.out.println("---单击增加按钮---");
				list.update();
				cb.update();
				userNameTextBox.update();
			}
			//从列表框选择客户
			else if(c == list) {
				System.out.println("---从列表框选择客户---");
				cb.select();
				userNameTextBox.setText();
			}
		}
	
	}

抽象组件类：抽象同事类

	public abstract class Component {
		protected Mediator mediator;
		
		public void setMediator(Mediator mediator) {
			this.mediator = mediator;
		}
		//转发调用
		public void changed() {
			mediator.componentChanged(this);
		}
		
		public abstract void update();
	}

按钮类：具体同事类

	public class Button extends Component {
		public void update() {
			//按钮不产生响应
		}
	}

列表框类：具体同事类

	public class List extends Component {
	
		public void update() {
			System.out.println("列表框增加一项：张无忌");
		}
		
		public void select() {
			System.out.println("列表框选中项：小龙女");
		}
	}

组合框类：具体同事类

	public class ComboBox extends Component {
	
		@Override
		public void update() {
			System.out.println("组合框增加一项：张无忌");
		}
		
		public void select() {
			System.out.println("组合框选中框：小龙女");
		}
	}

文本框：具体同事类

	public class TextBox extends Component {
	
		@Override
		public void update() {
			System.out.println("客户信息增加成功后文本框清空");
		}
		
		public void setText() {
			System.out.println("文本框显示：小龙女");
		}
		
	}

客户端

	public class Client {
		public static void main(String[] args) {
			//定义中介者对象
			ConcreteMediator mediator;
			mediator =new ConcreteMediator();
			
			//定义同事对象
			Button addBT = new Button();
			List list = new List();
			ComboBox cb = new ComboBox();
			TextBox userNameTB = new TextBox();
			
			addBT.setMediator(mediator);
			list.setMediator(mediator);
			cb.setMediator(mediator);
			userNameTB.setMediator(mediator);
			
			mediator.addButton = addBT;
			mediator.list = list;
			mediator.cb = cb;
			mediator.userNameTextBox = userNameTB;
			
			addBT.changed();
			System.out.println("---------------------------");
			list.changed();
		}
	}

中介者和同事类的扩展

需要在原有的系统上，增加一个新的组件Label（即新的同事类），有以下两种方案：

  1. 增加一个组件类Label，修改原有的具体中介者ConcreteMeditator，增加一个对Label对象的引用，然后修改componentChanged()方法中其他组件对象的业务修改代码，原有组件类无需任何修改，客户端代码也需针对新增的组件Label进行适当的修改

  2. 与方案1一样，首先增加一个Label类，但不修改原有具体中介者类ConcreteMediator的代码，而是增加一个ConcreteMediator的子类SubConcreteMediator来实现对Label对象的引用，然后在新增的中介者SubConcreteMediator中通过覆盖component Changed()方法来实现所有组件(包括新增Label组件)之间的交互，同样，原有组件类无需做任何修改，客户端代码只需少许修改

类结构图

引入Label之后，类结构图如下：

结构图

由于方案2无需修改ConcreteMediator类，更加符合开闭原则，因此选择方案2对新增Label类进行修改，如下

代码实现

文本标签类：具体同事类

	public class Label extends Component{
	
		@Override
		public void update() {
			System.out.println("文本标签内容改变，客户信息总数加1");
		}
	}

新增具体中介者类

	public class SubConcreteMediator extends ConcreteMediator {
		
		//增加对Label对象的引用
		public Label label;
		
		@Override
		public void componentChanged(Component c) {
			//单击按钮
			if(c == addButton) {
				System.out.println("---单击增加按钮---");
				list.update();
				cb.update();
				userNameTextBox.update();
				label.update();		//文本
			}
			//从列表框选择客户
			else if(c == list) {
				System.out.println("---从列表框选择客户---");
				cb.select();
				userNameTextBox.setText();
			}
		}
	}

客户端测试

	public class Client {
		public static void main(String[] args) {
			//用新增具体中介者定义中介者对象
			SubConcreteMediator mediator;
			mediator = new SubConcreteMediator();
			
			Button addBT = new Button();
			List list = new List();
			ComboBox cb = new ComboBox();
			TextBox userNameTB = new TextBox();
			Label label = new Label();
			
			addBT.setMediator(mediator);
			list.setMediator(mediator);
			cb.setMediator(mediator);
			userNameTB.setMediator(mediator);
			label.setMediator(mediator);
			
			mediator.addButton = addBT;
			mediator.list = list;
			mediator.cb = cb;
			mediator.userNameTextBox = userNameTB;
			mediator.label = label;
			
			addBT.changed();
			System.out.println("-----------------");
			list.changed();
		}
	
	}

在中介者模式的实际使用过程中，如果需要引入新的具体同事类，只需要继承抽象同事类并实现其中的方法即可，由于具体同事类之间并无直接的引用关系，因此原有所有同事类无需进行任何修改，它们与新增同事对象之间的交互可以通过修改或者增加具体中介者类来实现；如果需要在原有系统中增加新的具体中介者类，只需要继承抽象类（或者已有的具体中介者类）并覆盖其中定义的方法即可，在新的具体中介者中可以通过不同的方式来处理对象之间的交互，也可以增加对新增同事的引用和调用。在客户端中只需要修改少许代码（如果引入配置文件的话有时可以不修改任何代码）就可以实现中介者的更换。

总结

中介者模式将一个网状的系统结构变成一个以中介者对象为中心的星型结构，在这个星型结构中，使用中介者对象和其他对象的一对多关系来取代原有对象之间的多对多关系。中介者模式在事件驱动类软件中应用较为广泛，特别是基于GUI的软件。此外，在类与类之间存在错综复杂的关联关系的系统中，中介者模式都得到较好的应用。

优点

  1. 中介者模式简化了对象之间的交互，它用了中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解，维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构

  2. 中介者模式可将个同事对象解耦。中介者有利于各同事之间的松耦合，可以独立地改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便，更加符合开闭原则

  3. 可以大量减少同事子类生成，中介者将分布于多个对象间地行为集中在一起，改变这些行为只需要生成新的中介者子类即可，这使得各个同事类可以被重用，无需对同事类进行扩展。

缺点

在具体中介者类中包含了大量同事之间地交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。

适用场景

  1. 系统中对象之间存在复杂地引用关系，系统结构混乱并且难以理解

  2. 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。

  3. 想通过一个中间类来封装多个类中地行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果改变行为则可以增加新的具体中介者类。

上次更新: 9/22/2020, 12:20:37 AM

备忘录模式