1.描述

用一個中介者對象封裝一系列的對象交互。中介者使各對象不需要顯示的交互引用，從而使其歐合格松散，而且可以獨立的改變他們之間的交互。

2.模式的使用

·中介者（Mediator）：中介者是一個接口，該接口定義了用於同事（Colleague）對象之間進行通信的方法。

·具體中介者（ConcreteMediator）：具體中介者是實現中介者接口的類。具體中介者需要包含有所有具體同事（ConcreteColleague）的引用，並通過實現中介者接口中的方法來滿足具體同事之間的通信請求。

·同事（Colleague）：一個接口，規定了具體同事需要實現的方法。

·具體同事（ConcreteColleague）：實現同事接口的類。具體同事需要包含具體中介者的引用，一個具體同事需要和其他具體同事交互時，只需將自己的請求發送給中介者即可。

3.使用情景

·許多對象以復雜的形式交互，所導致的依賴關系使系統難以理解和維護。

·一個對象引用其他很多對象，導致該對象難以被復用。

·多各對象需要交互，不允許互相引用。

4.優點

·避免了許多需要通信的對象之間的顯示引用。

·通過中介者將分散於多個對象之間的交互行為集中起來。當交互行為需要改變時，只需改動中介者，不用改變每一個同事。

·各個同事完全解耦

5.UML圖

6.案例

現在有多個賣家（Seller）發布商品信息關註購買信息，多個買家（Buyer）發布購買信息關註出售信息。要求買家發布的信息賣家都能接受，賣家發布的信息買家都能接受。

  1 package mediator;
 
  2 
  3 import java.util.HashMap;
  4 import java.util.Iterator;
  5 import java.util.Set;
  6 
  7 public class test1 {
  8 
  9     public static void main(String[] args) {
 10         ConcreteMediator mediator  = new ConcreteMediator();
 11         Buyer b1 = new Buyer1(mediator);
 12         b1.setName("買家1");
 
 13         Buyer1 b2 = new Buyer1(mediator);
 14         b2.setName("買家2");
 15         Seller s1 = new Seller1(mediator);
 16         s1.setName("賣家1");
 17         Seller s2 = new Seller1(mediator);
 18         s2.setName("賣家2");
 19         b1.sendMess("我要買房子");
 20         b2.sendMess("我要買汽車");
 21         s1.sendMess("我要賣股票");
 22         s2.sendMess("我要賣房子");
 23     }
 24 
 25 }
 26 
 27 /*
 28  * 同事
 29  */
 30 interface Colleague{
 31     public void sendMess(String mess); //發布信息
 32     public void receiveMess(Colleague colleague, String mess);  //接受信息
 33     public void setName(String mess);
 34     public String getName();
 35 }
 36 
 37 /*
 38  * 買家抽象類
 39  */
 40 abstract class Buyer implements Colleague{
 41     private final static String IDENTITY= "我是買家";
 42     public String getIdentity(){
 43         return IDENTITY;
 44     }
 45 }
 46 
 47 /*
 48  * 賣家抽象類
 49  */
 50 abstract class Seller implements Colleague{
 51     private final static String IDENTITY= "我是賣家";
 52     public String getIdentity(){
 53         return IDENTITY;
 54     }
 55 }
 56 /*
 57  * 中介者
 58  */
 59 interface Mediator{
 60     public void registColleague(Colleague colleague);
 61     public void deliverMess(Colleague colleague, String mess);
 62 }
 63 
 64 /*
 65  * 具體中介者
 66  */
 67 class ConcreteMediator implements Mediator{
 68     /*
 69      * 在這裏采用HashMap容器。因為買賣雙方需要進行一對一的信息交互才能達成一致，肯定要對數
 70      * 據進行查詢，這種結構查詢很快。但在本案例中，只實現了一對多的廣播信息功能，實
 71      * 際上沒用到HashMap的查詢優勢。如果只進行遍歷，可以換成List結構。
 72      */
 73     private HashMap<Integer, Buyer> buyerMap; //儲存買家對象
 74     private HashMap<Integer, Seller> sellerMap;  //儲存賣家對象
 75     ConcreteMediator(){
 76         this.buyerMap = new HashMap<Integer, Buyer>();
 77         this.sellerMap = new HashMap<Integer, Seller>();
 78     }
 79     public void registColleague(Colleague colleague) {
 80         //先判斷是哪一類，再儲存買家、賣家的引用
 81         if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Buyer"))
 82             this.buyerMap.put(colleague.hashCode(), (Buyer) colleague);
 83         if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Seller"))
 84             this.sellerMap.put(colleague.hashCode(), (Seller) colleague);
 85     }
 86 
 87     public void deliverMess(Colleague colleague, String mess) {
 88         //買家將消息發送給所有賣家
 89         if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Buyer")){
 90             //遍歷HashMap的方法
 91             Set<Integer> set = this.sellerMap.keySet();
 92             Iterator<Integer> iterator = set.iterator();
 93             Integer i;
 94             while(iterator.hasNext()){
 95                 i = iterator.next();
 96                 this.sellerMap.get(i).receiveMess(this.sellerMap.get(i),mess);
 97             }
 98         }
 99         //賣家將所有消息發送給買家
100         if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Seller")){
101             //遍歷HashMap的方法
102             Set<Integer> set = this.buyerMap.keySet();
103             Iterator<Integer> iterator = set.iterator();
104             Integer i;
105             while(iterator.hasNext()){
106                 i = iterator.next();
107                 this.buyerMap.get(i).receiveMess(this.buyerMap.get(i), mess);
108             }
109         }
110     }
111     
112 } 
113 
114 /*
115  * 具體同事
116  */
117 class Buyer1 extends Buyer{
118     private String name;
119     Mediator mediator; //存儲中介者的引用，也許還有其他中介者用來實現其他的信息交互。
120     Buyer1(Mediator mediator){
121         this.mediator  = mediator;
122         mediator.registColleague(this);
123     }
124     public void sendMess(String mess) {
125         mediator.deliverMess(this, mess);
126     }
127 
128     public void receiveMess(Colleague colleague, String mess) {
129         System.out.println("賣家發出消息   " + colleague.getName() + "接受信息:" + mess);
130     }
131 
132     public void setName(String name) {
133         this.name  = name;
134     }
135 
136     public String getName() {
137         return name;
138     }
139 }
140 
141 /*
142  * 具體同事
143  */
144 class Seller1 extends Seller{
145     private String name;
146     Mediator mediator;
147     Seller1(Mediator mediator){
148         this.mediator  = mediator;
149         mediator.registColleague(this);
150     }
151     public void sendMess(String mess) {
152         mediator.deliverMess(this, mess);
153     }
154 
155     public void receiveMess(Colleague colleague, String mess) {
156         System.out.println("買家發出消息   " + colleague.getName() + "接受信息:" + mess);
157     }
158 
159     public void setName(String name) {
160         this.name  = name;
161     }
162 
163     public String getName() {
164         return name;
165     }
166 }

設計模式（九）——中介者模式