介绍
中介者模式(Mediator Pattern),用一个中介对象来封装一系列的对象交互,中介者使各个对象不需要显示的互相引用,从而使其耦合松散,而且可以独立的改变他们之间的交互 中介者模式属于行为型模式,代码易于维护 比如MVC模式,C(Controller控制器)是M(Model模型)和V(View视图)的中介者,在前后端交互时起到了中间人的作用
原理
Mediator就是抽象中介者,定义了同事对象到中介者对象的接口 Colleague是抽象同事类 ConcreteMediator是具体的中介者对象,实现抽象方法。它需要知道所有具体的同事类,即一个集合来管理HashMap,并接受某个同事对象消息,完成对应的任务 ConcreteColleague是具体的同事类,会有很多,每个同事只知道自己的行为,而不了解其他同事类的行为(方法),但是他们都依赖中介者对象
Mediator mediator = new ConcreteMediator ( ) ;
Alarm alarm = new Alarm ( mediator, "alarm" ) ;
CoffeeMachine coffeeMachine = new CoffeeMachine ( mediator,
"coffeeMachine" ) ;
Curtains curtains = new Curtains ( mediator, "curtains" ) ;
TV tV = new TV ( mediator, "TV" ) ;
alarm. SendAlarm ( 0 ) ;
coffeeMachine. FinishCoffee ( ) ;
alarm. SendAlarm ( 1 ) ;
public abstract class Mediator {
public abstract void Register ( String colleagueName, Colleague colleague) ;
public abstract void GetMessage ( int stateChange, String colleagueName) ;
public abstract void SendMessage ( ) ;
}
public class ConcreteMediator extends Mediator {
private HashMap< String, Colleague> colleagueMap;
private HashMap< String, String> interMap;
public ConcreteMediator ( ) {
colleagueMap = new HashMap < String, Colleague> ( ) ;
interMap = new HashMap < String, String> ( ) ;
}
@Override
public void Register ( String colleagueName, Colleague colleague) {
colleagueMap. put ( colleagueName, colleague) ;
if ( colleague instanceof Alarm ) {
interMap. put ( "Alarm" , colleagueName) ;
} else if ( colleague instanceof CoffeeMachine ) {
interMap. put ( "CoffeeMachine" , colleagueName) ;
} else if ( colleague instanceof TV ) {
interMap. put ( "TV" , colleagueName) ;
} else if ( colleague instanceof Curtains ) {
interMap. put ( "Curtains" , colleagueName) ;
}
}
@Override
public void GetMessage ( int stateChange, String colleagueName) {
if ( colleagueMap. get ( colleagueName) instanceof Alarm ) {
if ( stateChange == 0 ) {
( ( CoffeeMachine) ( colleagueMap. get ( interMap
. get ( "CoffeeMachine" ) ) ) ) . StartCoffee ( ) ;
( ( TV) ( colleagueMap. get ( interMap. get ( "TV" ) ) ) ) . StartTv ( ) ;
} else if ( stateChange == 1 ) {
( ( TV) ( colleagueMap. get ( interMap. get ( "TV" ) ) ) ) . StopTv ( ) ;
}
} else if ( colleagueMap. get ( colleagueName) instanceof CoffeeMachine ) {
( ( Curtains) ( colleagueMap. get ( interMap. get ( "Curtains" ) ) ) )
. UpCurtains ( ) ;
} else if ( colleagueMap. get ( colleagueName) instanceof TV ) {
} else if ( colleagueMap. get ( colleagueName) instanceof Curtains ) {
}
}
@Override
public void SendMessage ( ) {
}
}
public abstract class Colleague {
private Mediator mediator;
public String name;
public Colleague ( Mediator mediator, String name) {
this . mediator = mediator;
this . name = name;
}
public Mediator GetMediator ( ) {
return this . mediator;
}
public abstract void SendMessage ( int stateChange) ;
}
public class CoffeeMachine extends Colleague {
public CoffeeMachine ( Mediator mediator, String name) {
super ( mediator, name) ;
mediator. Register ( name, this ) ;
}
@Override
public void SendMessage ( int stateChange) {
this . GetMediator ( ) . GetMessage ( stateChange, this . name) ;
}
public void StartCoffee ( ) {
System. out. println ( "It's time to startcoffee!" ) ;
}
public void FinishCoffee ( ) {
System. out. println ( "After 5 minutes!" ) ;
System. out. println ( "Coffee is ok!" ) ;
SendMessage ( 0 ) ;
}
}
注意事项及细节
多个类相互耦合,会形成网状结构,使用中介者模式将网状结构分离成星型结构,进行解耦 减少类间依赖,降低了耦合,符合迪米特原则 中介者承担了较多的责任,一旦中介者出现了问题,整个系统就会受到影响 如果设计不当,中介者对象本身变得过于复杂,这点在使用时,要特别注意