设计模式之中介者模式(Mediator Pattern)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wangchengming1/article/details/84768795

• 中介者模式定义
  Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently. 用一个中介对象封装一系列的对象交互，中介者使各个对象不需要显示地相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。

• 中介者模式通用类图
  
  从以上类图可以看到，中介者模式主要有三个角色：

  • 抽象中介者：抽象中介者角色定义统一的接口，用于各个同事之间的通信。
  • 中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类。
  • 同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有一个，这其实是现实的省略，在实际应用中，同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。

• 中介者模式通用代码
  抽象中介者Mediator

public abstract class Mediator {

	protected ConcreteColleague1 c1;
	protected ConcreteColleague2 c2;
	
	public ConcreteColleague1 getC1() {
		return c1;
	}
	public void setC1(ConcreteColleague1 c1) {
		this.c1 = c1;
	}
	public ConcreteColleague2 getC2() {
		return c2;
	}
	public void setC2(ConcreteColleague2 c2) {
		this.c2 = c2;
	}
	
	public abstract void doSth1();
	public abstract void doSth2();
}

抽象同事类Colleague

public abstract class Colleague {

	protected Mediator mediator;

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

具体中介者

public class ConcreteMediator extends Mediator{

	@Override
	public void doSth1() {
		super.c1.selfMethod1();
		super.c2.selfMethod2();
	}

	@Override
	public void doSth2() {
		super.c1.selfMethod1();
		super.c2.selfMethod2();
	}
}

具体同事类

public class ConcreteColleague1 extends Colleague {

	public ConcreteColleague1(Mediator _mediator) {
		super(_mediator);
	}

	public void selfMethod1() {
		//TODO
	}

	public void depMethod1() {
		super.mediator.doSth1();
	}
}

public class ConcreteColleague2 extends Colleague {

	public ConcreteColleague2(Mediator _mediator) {
		super(_mediator);
	}

	public void selfMethod2() {
		// TODO
	}

	public void depMethod2() {
		super.mediator.doSth2();
	}
}

• 中介者模式实例类图
  相比有很多男生都喜欢金庸的武侠小说吧，笔者也不例外。江湖中门派众多，总会有一些小喽啰偷学少林绝学去做一些见不得人的勾当。前段时间武当派和峨眉派的的弟子被大力金刚指所杀，大力金刚指是少林派的绝学，自古有天下武功出少林的没说，大家自然也不敢轻举妄动。这个时候大家推举出了德高望重的武林盟主，作为江湖的中间人，一旦有什么不和谐的地方，由武林盟主出面进行沟通，其实这个例子就符合中介者模式。

• 中介者模式实例代码
  抽象中介者类

public abstract class WulinAlliance {

	abstract void notice(String message, United united);
}

抽象同事类

public abstract class United {

	protected WulinAlliance wulinAlliance;

	public United(WulinAlliance wulinAlliance) {
		this.wulinAlliance = wulinAlliance;
	}
}

具体同事类

public class Wudang extends United {
	public Wudang(WulinAlliance wulinAlliance) {
		super(wulinAlliance);
	}

	public void sendAlliance(String message) {
		wulinAlliance.notice(message, this);
	}

	public void getNotice(String message) {
		System.out.println("武当收到消息：" + message);
	}
}

public class Shaolin extends United {
	public Shaolin(WulinAlliance wulinAlliance) {
		super(wulinAlliance);
	}

	public void sendAlliance(String message) {
		wulinAlliance.notice(message, Shaolin.this);
	}

	public void getNotice(String message) {
		System.out.println("少林收到消息：" + message);
	}
}

public class Emei extends United {
    public Emei(WulinAlliance wulinAlliance) {
        super(wulinAlliance);
    }
    public void sendAlliance(String message) {
        wulinAlliance.notice(message, Emei.this);
    }
    public void getNotice(String message) {
        System.out.println("峨眉收到消息：" + message);
    }
}

具体中介者类

public class Champions extends WulinAlliance {
	private Wudang wudang;
	private Shaolin shaolin;
	private Emei emei;

	public void setWudang(Wudang wudang) {
		this.wudang = wudang;
	}

	public void setEmei(Emei emei) {
		this.emei = emei;
	}

	public void setShaolin(Shaolin shaolin) {
		this.shaolin = shaolin;
	}

	@Override
	public void notice(String message, United united) {
		if (united == wudang) {
			shaolin.getNotice(message);
		} else if (united == emei) {
			shaolin.getNotice(message);
		} else if (united == shaolin) {
			wudang.getNotice(message);
			emei.getNotice(message);
		}
	}
}

客户端调用

public class Client {
	public static void main(String[] args) {
		Champions champions = new Champions();
		Wudang wudang = new Wudang(champions);
		Shaolin shaolin = new Shaolin(champions);
		Emei emei = new Emei(champions);
		champions.setWudang(wudang);
		champions.setShaolin(shaolin);
		champions.setEmei(emei);
		wudang.sendAlliance("武当弟子被少林大力金刚指所杀");
		emei.sendAlliance("峨眉弟子被少林大力金刚指所杀");
		shaolin.sendAlliance("少林弟子绝不会做出这种事情");
	}
}

输出结果：

少林收到消息：武当弟子被少林大力金刚指所杀
少林收到消息：峨眉弟子被少林大力金刚指所杀
武当收到消息：少林弟子绝不会做出这种事情
峨眉收到消息：少林弟子绝不会做出这种事情

• 中介者模式的优点
  • 符合迪米特原则，将原有的一对多的依赖变成了一对一的依赖，降低类间的耦合。
  • 使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。
• 中介者模式的适用场景
  • 系统中对象之间存在比较复杂的引用关系，导致他们之间的依赖关系结构混乱而且难以复用该对象。
  • 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

参考书籍：设计模式之禅
实例代码放在这里。