中介者模式又称调停者模式,属于行为型模式;中介者模式包装了一系列对象相互作用的方式,使得这些对象不必互相明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时,不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。
在中介者模式中,所有的成员对象都与一个处于中心地位的中介者对象发生紧密的联系,由这个中介者对象进行协调工作。所有被协调的对象称为同事对象。在所有同事对象内部发生的事件会影响到其他的同事对象,但是这种影响不是以直接管理的方式直接传到其他的对象上的,仅仅直接影响到中介者对象,而由中介者对象反过来协调其他的同事,形成整个系统的行为。
在实际开发中,一个系统可能会调用周边的很多系统,那么在这个系统有大量的其他系统的实例对象,这些对象既会影响别的对象,又会被别的对象所影响,因此常常叫做同事(Colleague)对象。这些同事对象通过彼此的相互作用形成系统的行为。如下图所示,几乎每一个对象都需要与其他的对象发生相互作用,而这种相互作用表现为一个对象与另一个对象的直接耦合。这是一个过度耦合的系统。
通过引入中介者对象(Mediator),可以将系统的网状结构变成以中介者为中心的星形结构,如下图所示。在这个星形结构中,同事对象不再通过直接的联系与另一个对象发生相互作用;相反地,它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定,也就是说,系统的结构不会因为新对象的引入造成大量的修改工作。
比起传统的设计方法,面向对象的技术可以更好地协助开发者管理更为复杂的系统。一个好的面向对象的设计可以使对象之间增加协作性(Collaboration),减少耦合度(Coupling)。一个深思熟虑的设计会把一个系统分解为一群相互协作的同事对象,给每一个同事对象以独特的责任,恰当的配置它们之间的协作关系,使它们可以在一起工作。
如同阿里开源的异构数据源离线同步工具--DataX,下图是他的设计图:
中介者模式的UML类图如下:
如上图所示,中介者模式涉及到四种角色:
在一个智能家电的系统中,包括闹钟、咖啡机、电视机、窗帘等家具组成,当主人要看电视时,各个设备可以协同工作,自动完成看电视的准备工作。比如:闹钟响起 --> 咖啡机打开做咖啡 --> 窗帘自动降下 --> 电视机开始播放;在这里就以这个为例子讲解。
例子的UML类图如下:
抽象中介者角色:
package com.charon.mediator; /** * @className: Mediator * @description: 抽象中介者对象 * @author: charon * @create: 2022-04-03 23:16 */ public abstract class Mediator { /** * 将同事对象注册到中介者类中 * @param colleagueName * @param colleage */ abstract void register(String colleagueName, Colleague colleage); /** * 接收由具体的同事对象发出的消息 * @param stateChange * @param colleagueName */ abstract void getMessage(int stateChange,String colleagueName); /** * 发送消息 */ abstract void sendMessage(); }
具体中介者角色:
package com.charon.mediator; import java.util.HashMap; import java.util.Map; /** * @className: ConcreteMediator * @description: * @author: charon * @create: 2022-04-03 23:26 */ public class ConcreteMediator extends Mediator{ /** * 用于存放所有的同事对象 */ private Map<String,Colleague> colleagueMap; private Map<String,String> interMap; public ConcreteMediator() { this.colleagueMap = new HashMap<>(); this.interMap = new HashMap<>(); } @Override void register(String colleagueName, Colleague colleage) { colleagueMap.put(colleagueName,colleage); if(colleage instanceof Alarm){ interMap.put("alarm",colleagueName); }else if(colleage instanceof CoffeeMachine){ interMap.put("coffeeMachine",colleagueName); }else if (colleage instanceof TV){ interMap.put("tv",colleagueName); }else if (colleage instanceof Curtains){ interMap.put("curtains",colleagueName); } } @Override void getMessage(int state, String colleagueName) { if (colleagueMap.get(colleagueName) instanceof Alarm){ if(state == 0){ ((CoffeeMachine)colleagueMap.get(interMap.get("coffeeMachine"))).startCoffee(); ((TV)colleagueMap.get(interMap.get("tv"))).startTv(); }else if(state == 1){ ((TV)colleagueMap.get(interMap.get("tv"))).stopTv(); } }else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){ ((Curtains)colleagueMap.get(interMap.get("curtains"))).upCurtains(); } } @Override void sendMessage() { } }
抽象同事角色:
package com.charon.mediator; /** * @className: Colleague * @description: * @author: charon * @create: 2022-04-03 23:18 */ public abstract class Colleague { private Mediator mediator; private String name; public Colleague(Mediator mediator, String name) { this.mediator = mediator; this.name = name; } /** * Gets the value of mediator * * @return the value of mediator */ public Mediator getMediator() { return mediator; } /** * Gets the value of name * * @return the value of name */ public String getName() { return name; } abstract void sendMessage(int stateChange); }
具体同事角色:
package com.charon.mediator; /** * @className: Curtains * @description: 窗帘 * @author: charon * @create: 2022-04-03 23:34 */ public class Curtains extends Colleague{ @Override void sendMessage(int stateChange) { this.getMediator().getMessage(stateChange,this.getName()); } public Curtains(Mediator mediator, String name) { super(mediator, name); mediator.register(name,this); } public void upCurtains(){ System.out.println("窗帘在上升。。。。"); } public void downCurtains(){ System.out.println("窗帘在下降。。。。"); } } package com.charon.mediator; /** * @className: TV * @description: * @author: charon * @create: 2022-04-03 23:33 */ public class TV extends Colleague{ public TV(Mediator mediator, String name) { super(mediator, name); mediator.register(name, this); } @Override void sendMessage(int stateChange) { this.getMediator().getMessage(stateChange,this.getName()); } public void startTv(){ System.out.println("电视机开机。。。"); } public void stopTv(){ System.out.println("电视机关机。。。"); } } package com.charon.mediator; /** * @className: CoffeeMachine * @description: * @author: charon * @create: 2022-04-03 23:32 */ public class CoffeeMachine extends Colleague{ public CoffeeMachine(Mediator mediator, String name) { super(mediator, name); mediator.register(name,this); } @Override void sendMessage(int stateChange) { this.getMediator().getMessage(stateChange,this.getName()); } public void startCoffee(){ System.out.println("咖啡机启动。。。。"); } public void stopCoffee(){ System.out.println("咖啡机关闭。。。。"); sendMessage(0); } } package com.charon.mediator; /** * @className: Alarm * @description: * @author: charon * @create: 2022-04-03 23:30 */ public class Alarm extends Colleague{ public Alarm(Mediator mediator, String name) { super(mediator, name); mediator.register(name,this); } @Override void sendMessage(int stateChange) { this.getMediator().getMessage(stateChange,this.getName()); } void sendAlarm(int statChange){ sendMessage(0); } }
客户端测试:
package com.charon.mediator; /** * @className: Client * @description: http://c.biancheng.net/view/1393.html * @author: charon * @create: 2022-03-31 23:14 */ public class Client { public static void main(String[] args) { Mediator mediator = new ConcreteMediator(); Alarm alarm = new Alarm(mediator, "alarm"); CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine"); Curtains curtain = new Curtains(mediator, "curtain"); TV tv = new TV(mediator, "tv"); // 闹钟发出声响 alarm.sendAlarm(0); coffeeMachine.stopCoffee(); alarm.sendAlarm(1); } } 打印: 咖啡机启动。。。。 电视机开机。。。 咖啡机关闭。。。。 窗帘在上升。。。。 咖啡机启动。。。。 电视机开机。。。
中介者模式的主要优点如下:
其主要缺点是:
门面模式和中介者模式很相似,两者均是用来给出一个底耦合度的系统。门面模式为一个子系统提供一个简单的接口,其中消息的传送时单方向的,因为门面模式的客户端只通过门面类向子系统发出消息,而不是相反的情况。
中介者模式则是中介类与同事对象的相互作用是多方向的。
中介者模式与观察者模式是功能相类似的设计模式,它们之间是相互竞争的关系。换言之,使用了其中一者往往意味着放弃另一者。观察者模式通过引入观察者对象和主题对象来达到将通信分散化的目的;而中介者模式则封装了对象之间的通信,从而将通信集中到一个个中介对象中。
观察者模式需要观察者对象和主题对象的相互协作才能达到目的,而且一个观察主题对象通常有几个观察者对象,而一个观察者对象也可以同时观察几个主题对象。
由于观察者模式将性能分散到几个对象中,因此更容易达到复用的目的。但是由于每一次通信都涉及几个对象,因此,使用观察者模式的设计可能不容易读懂。使用了中介者模式使得系统的通信都要经过这个中介者对象,在所涉及的同事对象数目不多的情况下,使用中介者模式的设计是比较容易懂的设计。
在观察者模式中,观察者与被观察者是不同的角色;而在中介者模式中,所有的同事对象都扮演同样的角色。