中介者模式

一、中介者模式

1、定义

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

中介者模式的核心思想是通过中介者解耦系统各层次对象的直接耦合，层次对象的对外依赖通信全部交由中介者转发。

2、结构

（1）模式的结构

主要角色如下：

• 抽象中介者（Mediator）：定义统一的接口，用于各个同事角色之间的通信。
• 具体中介者（ConcreteMediator）：从具体的同事对象接收消息，向具体同事对象发出命令，协调各同事间的协作。
• 抽象同事类（Colleague）：每一个同事对象均需要依赖中介者角色，与其他同事间通信时，交由中介者进行转发协作。
• 具体同事类（ConcreteColleague）：负责实现自发行为（Self-Method），转发依赖方法（Dep-Method）交由中介者进行协调。

3、优缺点

优点：

• 减少类间依赖，将多对多依赖转化成一对多，降低了类间耦合。
• 类间各司其职，符合迪米特法则。

缺点：

• 当同事类越多时，中介者就会越臃肿，变得复杂并且难以维护。

4、使用场景

• 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
• 交互的公共行为，如果需要改变行为，则可以增加新的中介者类。

二、模式的通用实现

代码如下：

public class MediatorPattern {

	public static void main(String[] args) {
		Mediator mediator = new ConcreteMediator();

		ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
		ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);

		colleagueA.selfMethodA();
		colleagueA.depMethodA();
		System.out.println("-------------");
		colleagueB.depMethodB();
	}
}

// 抽象中介者
abstract class Mediator {

	protected ConcreteColleagueA colleagueA;
	protected ConcreteColleagueB colleagueB;

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

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

	// 中介者业务逻辑
	public abstract void transferA();

	public abstract void transferB();
}

// 具体中介者
class ConcreteMediator extends Mediator {
	@Override
	public void transferA() {
		// 协调行为：A转发为B
		this.colleagueB.selfMethodB();
	}

	@Override
	public void transferB() {
		// 协调行为：B转发为A
		this.colleagueA.selfMethodA();

	}
}

// 抽象同事类
abstract class Colleague {
	protected Mediator mediator;

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

// 具体同事类
class ConcreteColleagueA extends Colleague {
	public ConcreteColleagueA(Mediator mediator) {
		super(mediator);
		this.mediator.setColleagueA(this);
	}

	// 自发行为
	public void selfMethodA() {
		// 自己逻辑
		System.out.println(this.getClass().getSimpleName() + " selfMethodA");
	}

	// 依赖方法
	public void depMethodA() {
		// 自己逻辑
		System.out.println(this.getClass().getSimpleName() + " depMethodA");
		// 无法处理的委托给中介者处理
		this.mediator.transferA();
	}
}

class ConcreteColleagueB extends Colleague {
	public ConcreteColleagueB(Mediator mediator) {
		super(mediator);
		this.mediator.setColleagueB(this);
	}

	// 自发行为
	public void selfMethodB() {
		// 自己逻辑
		System.out.println(this.getClass().getSimpleName() + " selfMethodB");
	}

	// 依赖方法
	public void depMethodB() {
		// 自己逻辑
		System.out.println(this.getClass().getSimpleName() + " depMethodB");
		// 无法处理的委托给中介者处理
		this.mediator.transferB();
	}
}

– 求知若饥，虚心若愚。