设计模式之——中介者模式

一、基本介绍

中介者模式（行为型）：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。

二、包含角色

1.抽象中介者：中介者的公共接口定义，并提供了同事类消息传递的方法。

2.具体中介者：实现抽象中介者接口，负责协调同事类之间的通信。

3.抽象同事类：定义同事类的公共接口，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。

4.具体同事类：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

三、案例及UML类图

案例说明：

                  买方的时候，需要通过中介公司去买卖方，当我们通过中介去交流时，中介会把消息传递给卖方，卖方回复时，中介会把消息传递给买方。

UML类图：

类HouseMedium：

public interface HouseMedium {

    /**
     * 发送消息给另外一个客户
     * @param msg 消息
     * @param customer 发送消息的人
     */
    void sendMsg(String msg, Customer customer);

    /**
     * 设置买卖方
     * @param buyer
     * @param seller
     */
    void setCustomer(Customer buyer,Customer seller);

}

说明：房产中介接口，抽象中介者，定义房产中间的公共方法。

类Wanda：

public class Wanda implements HouseMedium {

    //买方
    private Customer buyer;

    //卖方
    private Customer seller;


    @Override
    public void sendMsg(String msg, Customer customer) {
        if(customer == buyer) {
            seller.receiveMsg(msg);
        }else {
            buyer.receiveMsg(msg);
        }
    }

    @Override
    public void setCustomer(Customer buyer, Customer seller) {
        this.buyer = buyer;
        this.seller = seller;
    }
}

说明：万达公司，具体中介者，持有买卖方的引用，买方和买方的交流通过中介。

类Customer：

public interface Customer {

    /**
     * 发送消息
     * @param msg 消息
     */
    void sendMsg(String msg);

    /**
     * 接收消息
     * @param msg 消息
     */
    void receiveMsg(String msg);

说明：客户接口，抽象同事类，定义了客户的交流的接口。

类Buyer：

public class Buyer implements Customer {

    private HouseMedium houseMedium;

    public Buyer(HouseMedium houseMedium) {
        this.houseMedium = houseMedium;
    }

    @Override
    public void sendMsg(String msg) {
        houseMedium.sendMsg(msg,this);
    }

    @Override
    public void receiveMsg(String msg) {
        System.out.println(msg);
        System.out.println("价格太高，能否降价！");
    }
}

说明：买方，具体同事类，买房的人，持有中介者的引用，通过中介者交流。

类Seller：

public class Seller implements Customer {

    private HouseMedium houseMedium;

    public Seller(HouseMedium houseMedium) {
        this.houseMedium = houseMedium;
    }

    @Override
    public void sendMsg(String msg) {
        houseMedium.sendMsg(msg,this);
    }

    @Override
    public void receiveMsg(String msg) {
        System.out.println(msg);
        System.out.println("价格太低，能否高一些。");
    }
}

说明：卖方，具体同事类，卖房的人，持有中介者的引用，通过中介者交流。

类MediatorTest：

public class MediatorTest {

    public static void main(String[] args) {
        //中介者
        HouseMedium medium = new Wanda();
        //买方
        Customer buyer = new Buyer(medium);
        //卖方
        Customer seller = new Seller(medium);
        medium.setCustomer(buyer,seller);
        buyer.sendMsg("报价200万");
        seller.sendMsg("还价250万");
    }
}

说明：测试及客户端。

 

四、适用场景

1.当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。

2.想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

 

五、其它

注意：也可以不定义中介者接口，直接使用一个类作为中介者即可、