java设计模式-Mediator（中介者）模式

Mediator中介者模式定义  
    Mediator 中介者，或者叫仲裁者，类似房屋的中介，比如演播室的主播和嘉宾，主播在说话的时候，嘉宾不能打断他，主播停止说话的时候嘉宾才能说话，主播则可以随时说话，这里还有一个中间人： 
     1.主播对中介者说，节目开始了，我要说话了 
     2.中介者看看嘉宾是不是在说话，如果是在说话，让他停止，让主播说，如果嘉宾没在说话，让主播说 
     3.嘉宾告诉中介者说我要说话，中介者看看主播是否在说话，如果在说话，就告诉嘉宾说主播在说，你等等再说；如果主播不在说话，则让嘉宾说 

代码例子如下： 
 

Java代码  

1. package mediator;  
2. /* 
3.  * 中介者类，并和两个参与者进行关联，两个参与者在中介者这里注册 
4.  */  
5. public class Mediator {  
6.      private Anchor anchor;  
7.      private Guest guest;  
8.      public void regAnchor(Anchor anchor){  
9.       this.anchor=anchor;  
10.      }  
11.      public void regGuest(Guest guest){  
12.       this.guest=guest;  
13.      }  
14.      //中介代替主持人说话，如果嘉宾在说话，打断他，主持人说，主持人的状态变为忙碌  
15.     public void anchorSpeak(){  
16.      if(!guest.isFree()){  
17.       guest.stop();  
18.      }  
19.      System.out.println("Anchor is speaking....");  
20.      anchor.setFree(false);  
21.     }  
22.     //中介代替嘉宾说话，如果主持人空闲，嘉宾才能说话，嘉宾状态变为忙碌，  
23.     //否则，不让嘉宾说话，主持人继续说  
24.     public void guestSpeak(){  
25.      if(anchor.isFree()){  
26.       System.out.println("Guest is speaking....");  
27.       guest.setFree(false);  
28.      }  
29.      else{  
30.       System.out.println("Anchor is speaking. Do not interrupt...");  
31.      }  
32.        
33.     }  
34.     //中介代替主持人停止说话，设置状态为空闲  
35.     public void anchorStop(){  
36.      System.out.println("Anchor stop speaking now....");  
37.      anchor.setFree(true);  
38.     }  
39.     //中介代替嘉宾停止说话，设置状态为空闲  
40.     public void guestStop(){  
41.      System.out.println("Guest stop speaking now...");  
42.      guest.setFree(true);  
43.        
44.     }  
45.     }  

     

Java代码  

1. package mediator;  
2. /* 
3.  * 主持人类，有一个状态，是否处于空闲状态 
4.  * 有一个终结者的私有属性，和中介者产生关系 
5.  */  
6. public class Anchor {  
7.          private boolean free;  
8.   
9.          private Mediator med;  
10.          public Anchor(Mediator md){  
11.           med=md;  
12.          }  
13.   
14.          public boolean isFree() {  
15.           return free;  
16.          }  
17.   
18.          public void setFree(boolean free) {  
19.           this.free = free;  
20.          }  
21.   
22.          //通过中介者来开始说话  
23.          public void speak() {  
24.           med.anchorSpeak();  
25.          }  
26.   
27.          //通过中介者来停止说话  
28.          public void stop() {  
29.           med.anchorStop();  
30.          }  
31.       
32. }  

Java代码  

1. package mediator;  
2. /* 
3.  * 嘉宾类，私有属性标记是否空闲 
4.  * 私有属性中介者，与中介者产生关系 
5.  */  
6. public class Guest {  
7.      private boolean free;  
8.   
9.      private Mediator med;  
10.   
11.      public Guest(Mediator md) {  
12.       this.med = md;  
13.      }  
14.   
15.      public boolean isFree() {  
16.       return free;  
17.      }  
18.   
19.      public void setFree(boolean free) {  
20.       this.free = free;  
21.      }  
22.   
23.      //通过中介者开始说话  
24.      public void speak() {  
25.       med.guestSpeak();  
26.   
27.      }  
28.      //通过中介者停止说话  
29.      public void stop() {  
30.       med.guestStop();  
31.      }  
32.     }  

Java代码  

1. package mediator;  
2.   
3. public class Test {  
4.      public static void main(String[] args) {  
5.           // TODO Auto-generated method stub  
6.          //新建一个中介者  
7.           Mediator med = new Mediator();  
8.             
9.           //新建一个主持人，并和中介者关联，让主持人知道中介都有什么能力（什么方法）  
10.           Anchor anchor = new Anchor(med);  
11.             
12.           //新建一个嘉宾，并和中介者关联，让嘉宾知道中介都能什么能力（什么方法）  
13.           Guest guest=new Guest(med);  
14.             
15.           //在中介者里面，注册主持人，和嘉宾，让中介者知道嘉宾和主持人都需要什么  
16.           med.regAnchor(anchor);  
17.           med.regGuest(guest);  
18.             
19.           //主持人说  
20.           anchor.speak();  
21.             
22.           //嘉宾说  
23.           guest.speak();  
24.             
25.           //主持人停止  
26.           anchor.stop();  
27.             
28.           //嘉宾说  
29.           guest.speak();  
30.             
31.           //主持人说  
32.           anchor.speak();  
33.             
34.          }  
35. }  

 

    中介者就是一个处于众多对象，并恰当地处理众多对象之间相互之间的联系的角色。 
     
     以上代码中只有两个参与者类，，但是这些我们都可以根据中介者模式的宗旨进行适当地扩展，即增加参与者类，然后中介者就得担负更加重的任务了，我们看到上面具体中介者类Mediator中的方法比较多而且有点乱。 

     所以，在解耦参与者类之间的联系的同时，中介者自身也不免任务过重，因为几乎所有的业务逻辑都交代到中介者身上了，可谓是“万众期待”的一个角色了。这就是中介者模式的不足之处了 。 
     此外，上面这个代码例子的参与者的属性和方法都是一样的，我们可以抽取一个抽象类出来，减少代码，但是有时候我们根本抽取不了多个“参与者”之间的共性来形成一个抽象类，这也大大增加了中介者模式的使用难度。