什麼是中介者模式
Mediator模式也叫中介者模式，是由GoF提出的23種軟件設計模式的一種。Mediator模式是行爲模式之一，在Mediator的對象中，類之間的交互行爲被統一放在Medator的對象中，對象通過Mediator對象同其他對象交互，Meiator 對象起着控制器的作用。
中介者（Mediator）模式的定義：定義一箇中介對象來封裝一系列對象之間的交互，使原有對象之間的耦合鬆散，且可以獨立地改變它們之間的交互。中介者模式又叫調停模式，它是迪米特法則的典型應用。
簡單來說：如果兩個類不必彼此直接通向，那麼這兩類就不應當發生直接的相互作用。如果其中一個類需要調用另一個類的某一個方法的話，可以通過第三者轉發這個調用。（比如 房產中介，婚姻介紹所）
中介者模式是一種對象行爲型模式，其主要優點如下。
1，降低了對象之間的耦合性，使得對象易於獨立地被複用。
2，將對象間的一對多關聯轉變爲一對一的關聯，提高系統的靈活性，使得系統易於維護和擴展。
其主要缺點是：當同事類太多時，中介者的職責將很大，它會變得複雜而龐大，以至於系統難以維護。
中介者模式結構圖
中介者模式包含以下主要角色。
1，抽象中介者（Mediator）角色：它是中介者的接口，提供了同事對象註冊與轉發同事對象信息的抽象方法。
2，具體中介者（ConcreteMediator）角色：實現中介者接口，定義一個 List 來管理同事對象，協調各個同事角色之間的交互關係，因此它依賴於同事角色。
3，抽象同事類（Colleague）角色：定義同事類的接口，保存中介者對象，提供同事對象交互的抽象方法，實現所有相互影響的同事類的公共功能。
4，具體同事類（Concrete Colleague）角色：是抽象同事類的實現者，當需要與其他同事對象交互時，由中介者對象負責後續的交互。
結構圖如下：
模式的應用場景
前面分析了中介者模式的結構與特點，下面分析其以下應用場景。
- 當對象之間存在複雜的網狀結構關係而導致依賴關係混亂且難以複用時。
- 當想創建一個運行於多個類之間的對象，又不想生成新的子類時。
中介者模式代碼實現
抽象中介者： 負責發送消息，同事對象註冊
/**
* @ClassName Mediator
* @Description 抽象的中介類
* @Version 1.0
**/
public abstract class Mediator {
/**
* 發送消息
* @param message
* @param colleague
*/
public abstract void send(String message, Colleague colleague);
}
具體中介者，實現中介者接口，協調各個同事角色之間 發送消息
/**
* @ClassName ColleagueMediator
* @Description 具體的中介類
* @Version 1.0
**/
public class ColleagueMediator extends Mediator {
private ConcreteColleague1 concreteColleague1;
private ConcreteColleague2 concreteColleague2;
/**
*協調同事，發送消息
*/
@Override
public void send(String message, Colleague colleague) {
if(colleague instanceof ConcreteColleague1){
concreteColleague2.receive(message);
}else{
concreteColleague1.receive(message);
}
}
public ConcreteColleague1 getConcreteColleague1() {
return concreteColleague1;
}
public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
this.concreteColleague1 = concreteColleague1;
}
public ConcreteColleague2 getConcreteColleague2() {
return concreteColleague2;
}
public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
this.concreteColleague2 = concreteColleague2;
}
}
抽象同事類（Colleague）角色：定義同事類的接口，保存中介者對象，提供同事對象交互的抽象方法，實現所有相互影響的同事類的公共功能。
/**
* @ClassName Colleague
* @Description 抽象的同事類
* @Version 1.0
**/
public abstract class Colleague {
/**
* 抽象的中介類
*/
protected Mediator mediator;
/**
* 構造方法得到 中介者對象
* @param mediator
*/
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void receive(String message);
public abstract void send(String message);
}
具體同事類（Concrete Colleague）角色：是抽象同事類的實現者，當需要與其他同事對象交互時，由中介者對象負責後續的交互。
/**
* @ClassName ConcreteColleague1
* @Description TODO
* @Version 1.0
**/
public class ConcreteColleague1 extends Colleague{
/**
* 構造方法得到 中介者對象
*
* @param mediator
*/
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
/**
* 發送消息
*/
@Override
public void send(String message){
//發送消息時由中介者去發送
System.out.println("同事1發送消息："+message);
mediator.send(message,this);
}
/**
* 接收消息
* @param message
*/
@Override
public void receive(String message){
System.out.println("同事1得到消息:"+message);
}
}
具體同事類（Concrete Colleague）角色：是抽象同事類的實現者，當需要與其他同事對象交互時，由中介者對象負責後續的交互。
/**
* @ClassName ConcreteColleague2
* @Description TODO
* @Version 1.0
**/
public class ConcreteColleague2 extends Colleague{
/**
* 構造方法得到 中介者對象
*
* @param mediator
*/
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
/**
* 發送消息
* @param message
*/
@Override
public void send(String message){
//發送消息時由中介者去發送
System.out.println("同事2發送消息："+message);
mediator.send(message,this);
}
/**
* 接收消息
* @param message
*/
@Override
public void receive(String message){
System.out.println("同事2得到消息:"+message);
}
}
測試
public class MainClass {
public static void main(String[] args) {
//中介者
ColleagueMediator mediator = new ColleagueMediator();
//通過中介者讓兩者聯繫
ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
mediator.setConcreteColleague1(colleague1);
mediator.setConcreteColleague2(colleague2);
//同事1發送消息
colleague1.send("你在幹什麼！！！");
System.out.println("----------------------------------");
//同事2發送消息
colleague2.send("我在想你呀！！！");
}
}
中介者模式的擴展
在實際開發中，通常採用以下兩種方法來簡化中介者模式，使開發變得更簡單。
- 不定義中介者接口，把具體中介者對象實現成爲單例。
- 同事對象不持有中介者，而是在需要的時直接獲取中介者對象並調用。
單例中介者
public class SimpleMediator{
private static final SimpleMediator smd=new SimpleMediator();
//同事類集合
private List<SimpleColleague> colleagues=new ArrayList<SimpleColleague>();
/**
*私有化構造方法
*/
private SimpleMediator(){
}
/**
*獲得中介者
*/
public static SimpleMediator getMediator(){
return(smd);
}
//註冊同事類
public void register(SimpleColleague colleague) {
if(!colleagues.contains(colleague)){
colleagues.add(colleague);
}
}
//發送消息
public void relay(SimpleColleague scl){
for(SimpleColleague ob:colleagues){
if(!ob.equals(scl)) {
((SimpleColleague)ob).receive();
}
}
}
}
其他的 跟之前的 中介者代碼實現裏的代碼一致，就不多在編寫