中介者模式（Mediator Pattern）

中介者模式（用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互）

• 优点
  1、降低了类的复杂度，将一对多转化成了一对一。
  2、各个类之间的解耦。
  3、符合迪米特原则。

• 缺点
  1、当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

• 中介者模式包含以下主要角色
  抽象中介者：提供了同事对象注册与转发的抽象方法。
  具体中介者：定义一个 集合存储同事对象，实现中介者接口。
  抽象同事类：引入中介者对象，提供同事对象交互的抽象方法。
  具体同事类：实现抽象同事类，在同事对象交互接口里面调用了中介者中转发的接口。

• 例子：买房者和卖方者通过某房屋中介平台进项交流，类图如下
  

• 代码实现

抽象中介者：

/**
 * 中介者
 */
public interface Mediator {
    // 注册
    void register(Customer customer);
    // 转发
    void forward(Customer sender, String message);
}

具体中介者：

/**
 * 中介者实现
 */
public class ConcreteMediator implements Mediator {
    private List<Customer> customers = new ArrayList<>();

    @Override
    public void register(Customer customer) {
        if (!customers.contains(customer)) {
            customers.add(customer);
            customer.setMediator(this);
        }
    }

    @Override
    public void forward(Customer sender, String message) {
        for (Customer cus : customers) {
            if (cus == sender) continue;
            cus.receive(message);
        }
    }
}

抽象同事类：

/**
 * 客户
 */
public abstract class Customer {
    protected String name;
    protected Mediator mediator;

    public Customer(String name) {
        this.name = name;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    abstract void receive(String message);
    abstract void send(String message);
}

具体同事类：

/**
 * 卖方
 */
public class Seller extends Customer {

    public Seller(String name) {
        super(name);
    }

    @Override
    void receive(String message) {
        System.out.println(name + "(卖方)接收消息：" + message);
    }

    @Override
    void send(String message) {
        System.out.println(name + "(卖方)发送消息：" + message);
        mediator.forward(this, message);
    }
}
/**
 * 买方
 */
public class Buyer extends Customer {

    public Buyer(String name) {
        super(name);
    }

    @Override
    void receive(String message) {
        System.out.println(name + "(买方)接收消息：" + message);
    }

    @Override
    void send(String message) {
        System.out.println(name + "(买方)发送消息：" + message);
        mediator.forward(this, message);
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        Customer buyer1 = new Buyer("张三");
        Customer buyer2 = new Buyer("李四");
        Customer seller1 = new Seller("王五");
        Customer seller2 = new Seller("赵六");
        Mediator mediator = new ConcreteMediator();
        mediator.register(buyer1);
        mediator.register(buyer2);
        mediator.register(seller1);
        mediator.register(seller2);
        seller1.send("80平2室，100万，急卖");
        buyer1.send("80元卖不卖");
        seller2.send("小哥哥，我这80元卖，卖房送老婆孩子");
        buyer2.send("我也要");
    }
}
// 运行结果
王五(卖方)发送消息：80平2室，100万，急卖
张三(买方)接收消息：80平2室，100万，急卖
李四(买方)接收消息：80平2室，100万，急卖
赵六(卖方)接收消息：80平2室，100万，急卖
张三(买方)发送消息：80元卖不卖
李四(买方)接收消息：80元卖不卖
王五(卖方)接收消息：80元卖不卖
赵六(卖方)接收消息：80元卖不卖
赵六(卖方)发送消息：小哥哥，我这80元卖，买房送老婆孩子
张三(买方)接收消息：小哥哥，我这80元卖，买房送老婆孩子
李四(买方)接收消息：小哥哥，我这80元卖，买房送老婆孩子
王五(卖方)接收消息：小哥哥，我这80元卖，买房送老婆孩子
李四(买方)发送消息：我也要
张三(买方)接收消息：我也要
王五(卖方)接收消息：我也要
赵六(卖方)接收消息：我也要