设计模式（九）——中介者模式

1.描述

用一个中介者对象封装一系列的对象交互。中介者使各对象不需要显示的交互引用，从而使其欧合格松散，而且可以独立的改变他们之间的交互。

2.模式的使用

·中介者（Mediator）：中介者是一个接口，该接口定义了用于同事（Colleague）对象之间进行通信的方法。

·具体中介者（ConcreteMediator）：具体中介者是实现中介者接口的类。具体中介者需要包含有所有具体同事（ConcreteColleague）的引用，并通过实现中介者接口中的方法来满足具体同事之间的通信请求。

·同事（Colleague）：一个接口，规定了具体同事需要实现的方法。

·具体同事（ConcreteColleague）：实现同事接口的类。具体同事需要包含具体中介者的引用，一个具体同事需要和其他具体同事交互时，只需将自己的请求发送给中介者即可。

3.使用情景

·许多对象以复杂的形式交互，所导致的依赖关系使系统难以理解和维护。

·一个对象引用其他很多对象，导致该对象难以被复用。

·多各对象需要交互，不允许互相引用。

4.优点

·避免了许多需要通信的对象之间的显示引用。

·通过中介者将分散于多个对象之间的交互行为集中起来。当交互行为需要改变时，只需改动中介者，不用改变每一个同事。

·各个同事完全解耦

5.UML图

6.案例

现在有多个卖家（Seller）发布商品信息关注购买信息，多个买家（Buyer）发布购买信息关注出售信息。要求买家发布的信息卖家都能接受，卖家发布的信息买家都能接受。

package mediator;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class test1 {

    public static void main(String[] args) {
        ConcreteMediator mediator  = new ConcreteMediator();
        Buyer b1 = new Buyer1(mediator);
        b1.setName("买家1");
        Buyer1 b2 = new Buyer1(mediator);
        b2.setName("买家2");
        Seller s1 = new Seller1(mediator);
        s1.setName("卖家1");
        Seller s2 = new Seller1(mediator);
        s2.setName("卖家2");
        b1.sendMess("我要买房子");
        b2.sendMess("我要买汽车");
        s1.sendMess("我要卖股票");
        s2.sendMess("我要卖房子");
    }

}

/*
 * 同事
 */
interface Colleague{
    public void sendMess(String mess); //发布信息
    public void receiveMess(Colleague colleague, String mess);  //接受信息
    public void setName(String mess);
    public String getName();
}

/*
 * 买家抽象类
 */
abstract class Buyer implements Colleague{
    private final static String IDENTITY= "我是买家";
    public String getIdentity(){
        return IDENTITY;
    }
}

/*
 * 卖家抽象类
 */
abstract class Seller implements Colleague{
    private final static String IDENTITY= "我是卖家";
    public String getIdentity(){
        return IDENTITY;
    }
}
/*
 * 中介者
 */
interface Mediator{
    public void registColleague(Colleague colleague);
    public void deliverMess(Colleague colleague, String mess);
}

/*
 * 具体中介者
 */
class ConcreteMediator implements Mediator{
    /*
     * 在这里采用HashMap容器。因为买卖双方需要进行一对一的信息交互才能达成一致，肯定要对数
     * 据进行查询，这种结构查询很快。但在本案例中，只实现了一对多的广播信息功能，实
     * 际上没用到HashMap的查询优势。如果只进行遍历，可以换成List结构。
     */
    private HashMap<Integer, Buyer> buyerMap; //储存买家对象
    private HashMap<Integer, Seller> sellerMap;  //储存卖家对象
    ConcreteMediator(){
        this.buyerMap = new HashMap<Integer, Buyer>();
        this.sellerMap = new HashMap<Integer, Seller>();
    }
    public void registColleague(Colleague colleague) {
        //先判断是哪一类，再储存买家、卖家的引用
        if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Buyer"))
            this.buyerMap.put(colleague.hashCode(), (Buyer) colleague);
        if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Seller"))
            this.sellerMap.put(colleague.hashCode(), (Seller) colleague);
    }

    public void deliverMess(Colleague colleague, String mess) {
        //买家将消息发送给所有卖家
        if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Buyer")){
            //遍历HashMap的方法
            Set<Integer> set = this.sellerMap.keySet();
            Iterator<Integer> iterator = set.iterator();
            Integer i;
            while(iterator.hasNext()){
                i = iterator.next();
                this.sellerMap.get(i).receiveMess(this.sellerMap.get(i),mess);
            }
        }
        //卖家将所有消息发送给买家
        if(colleague.getClass().getGenericSuperclass().toString().equals("class mediator.Seller")){
            //遍历HashMap的方法
            Set<Integer> set = this.buyerMap.keySet();
            Iterator<Integer> iterator = set.iterator();
            Integer i;
            while(iterator.hasNext()){
                i = iterator.next();
                this.buyerMap.get(i).receiveMess(this.buyerMap.get(i), mess);
            }
        }
    }
    
} 

/*
 * 具体同事
 */
class Buyer1 extends Buyer{
    private String name;
    Mediator mediator; //存储中介者的引用，也许还有其他中介者用来实现其他的信息交互。
    Buyer1(Mediator mediator){
        this.mediator  = mediator;
        mediator.registColleague(this);
    }
    public void sendMess(String mess) {
        mediator.deliverMess(this, mess);
    }

    public void receiveMess(Colleague colleague, String mess) {
        System.out.println("卖家发出消息   " + colleague.getName() + "接受信息:" + mess);
    }

    public void setName(String name) {
        this.name  = name;
    }

    public String getName() {
        return name;
    }
}

/*
 * 具体同事
 */
class Seller1 extends Seller{
    private String name;
    Mediator mediator;
    Seller1(Mediator mediator){
        this.mediator  = mediator;
        mediator.registColleague(this);
    }
    public void sendMess(String mess) {
        mediator.deliverMess(this, mess);
    }

    public void receiveMess(Colleague colleague, String mess) {
        System.out.println("买家发出消息   " + colleague.getName() + "接受信息:" + mess);
    }

    public void setName(String name) {
        this.name  = name;
    }

    public String getName() {
        return name;
    }
}