中介者模式(Mediator):用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互。
一、中介者模式
1.1 为什么使用中介者模式?
在软件开发中,对象和对象之间存在着大量的关联关系,导致系统的结构变得复杂,可扩展性降低。举例来看,下图所示的各个国家之间的关系图,倘若再加入一个新的国家,需要和其相关联的国家进行连接,变得很复杂。
按照中介者模式的思想,我们加入一个联合国的中介者:
由网状结构变成星型结构,提高系统整体的扩展性,这里面就体现了中介者模式,其UML图如下:
中介者模式由以下部分组成:
抽象中介者(Mediator): 定义了同事对象到中介者对象之间的接口。
具体中介者(ConcreteMediator): 实现抽象中介者的方法,它需要知道所有的具体同事类,同时需要从具体的同事类那里接收信息,并且向具体的同事类发送信息。
抽象同事类(Colleague): 实现同事类之间的公共功能。
具体同事类(ConcreteColleague): 每个具体同事类都只需要知道自己的行为即可,但是他们都需要认识中介者。
代码部分:
interface Mediator{
void change(Colleague colleague);
}
abstract class Colleague{
private Mediator mediator;
protected Colleague(Mediator mediator) {
this.mediator = mediator;
}
public Mediator getMediator() {
return mediator;
}
public abstract void someOperation();
}
class ConcreteColleagueA extends Colleague{
protected ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
public void someOperation(){
System.out.println("我是同事A");;
}
}
class ConcreteColleagueB extends Colleague{
protected ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
public void someOperation(){
System.out.println("我是同事B");;
}
}
class ConcreteMediator implements Mediator{
private Colleague colleague;
public void setColleague(Colleague colleague) {
this.colleague = colleague;
}
@Override
public void change(Colleague colleague) {
colleague.someOperation();
}
}
客户端调用:
二、案例分析
我们以开篇联合国的例子,研究一下中介者模式:
定义中介者–联合国家组织抽象类
abstract class TheUnitedNations{
public abstract void constact(String message,Country country);
}
具体联合国:
class ConcreteMediator extends TheUnitedNations{
private China china;
private USA usa;
private Russia russia;
public China getChina() {
return china;
}
public void setChina(China china) {
this.china = china;
}
public USA getUsa() {
return usa;
}
public void setUsa(USA usa) {
this.usa = usa;
}
public Russia getRussia() {
return russia;
}
public void setRussia(Russia russia) {
this.russia = russia;
}
@Override
public void constact(String message, Country country) {
System.out.println("我是"+country.getName()+",我想说"+message);
}
}
国家抽象类:
abstract class Country{
private String name;
//持有中介者对象的引用,因为每个同事类都应该知道中介者对象
private TheUnitedNations mediator;
protected Country(String name ,TheUnitedNations mediator) {
this.mediator = mediator;
this.name = name;
}
public TheUnitedNations getMediator() {
return mediator;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
具体国家类:
class China extends Country{
public China(String name, TheUnitedNations mediator) {
super(name, mediator);
}
public void someOperation(String message){
super.getMediator().constact(message,this);
}
}
class USA extends Country{
public USA(String name, TheUnitedNations mediator) {
super(name, mediator);
}
public void someOperation(String message){
super.getMediator().constact(message,this);
}
}
class Russia extends Country{
public Russia(String name, TheUnitedNations mediator) {
super(name, mediator);
}
public void someOperation(String message){
super.getMediator().constact(message,this);
}
}
故事上演:
public class Test {
public static void main(String[] args) {
ConcreteMediator cm = new ConcreteMediator();
China c = new China("中国",cm);
USA usa = new USA("美国",cm);
Russia russia = new Russia("俄罗斯",cm);
cm.setRussia(russia);
cm.setChina(c);
cm.setUsa(usa);
c.someOperation("我是发展中国家");
usa.someOperation("我是世界警察,我爱维护和平");
russia.someOperation("战斗民族,能动手就.....");
}
}
运行结果(代码亲测,可以通过):
代码地址:Mediator
三、模式结语
中介者模式的优点:
简化了对象之间的关系,将系统的各个对象之间的相互关系进行封装,将各个同事类解耦,使系统成为松耦合系统。
减少了子类的生成。
可以减少各同事类的设计与实现。
中介者模式的适用场景:
系统中对象之间存在比较复杂的引用关系,导致他们之间的依赖关系结构混乱而且难以复用该对象。
想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。
欢迎大家评论留言,点击查看更多设计模式。