设计模式——中介者模式

• 中介者模式定义
  中介者对象封装系列的对象交互，中介者使得对象不需要显示地相互作用，从而松耦合，能够独立改变它们之间的交互。

• 中介者模式角色
  抽象中介者： 用于各个同事类之间的通信，同事类对象到中介者对象的接口。包括一个或几个抽象的事件方法，由子类实现。
  中介者实现类： 从一个同事类接收消息，通过消息影响其他同事类
  同事类： 如果一个对象会影响其他类，同时也会被其他类影响，这两个类互为同事类。

• 使用中介者模式的原因
  一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。

  在使用了中介者模式之后，同事类之间关系变成星型结构，由专门的类统一管理他们之间的关系。

• UML 图

• 中介者模式例子
  相对于机票购买这件事来说，客户、各航司、各代理商之间其实就有错综复杂。而去哪网的出现目标就是将这些错综复杂的关系整合，以去哪儿网平台为核心，呈现一个星型结构。

    public class User {

    /**
     * 用户名称
     */
    protected String name;

    /**
     * 中介者
     */
    protected Mediator mediator;

    public User(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

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

    public Mediator getMediator() {
        return mediator;
    }

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

    public class Visitor extends User {


    public Visitor(String name, Mediator mediator) {
        super(name, mediator);
    }

    /**
     * 与中介者联系
     *
     * @param message
     */
    public void constact(String message) {
        mediator.constact(message, this);
    }

    public void getMessage(String message) {
        System.out.println("访问者:" + name + ",获取信息:" + message);
    }
}

    public class Agents extends User {

    public Agents(String name, Mediator mediator) {
        super(name, mediator);
    }

    /**
     * 与中介者联系
     *
     * @param message
     */
    public void constact(String message) {
        mediator.constact(message, this);
    }

    public void getMessage(String message) {
        System.out.println("代理商:" + name + ",获取信息:" + message);
    }
}

    public interface Mediator {

    void constact(String message,User user);
}

    public class MediatorStructure implements Mediator {

    /**
     * 代理商
     */
    private Agents agents;

    /**
     * 用户
     */
    private Visitor visitor;


    public Agents getAgents() {
        return agents;
    }

    public void setAgents(Agents agents) {
        this.agents = agents;
    }

    public Visitor getVisitor() {
        return visitor;
    }

    public void setVisitor(Visitor visitor) {
        this.visitor = visitor;
    }

    public void constact(String message, User user) {
        //如果是代理商，则访问者获得信息
        if (user == agents) {
            visitor.getMessage(message);
        } else {
            agents.getMessage(message);
        }
    }
}

    public class Client {

    public static void main(String[] args) {

        MediatorStructure mediator = new MediatorStructure();

        Agents agents = new Agents("xxx机票代理商", mediator);
        Visitor visitor = new Visitor("李四", mediator);
        mediator.setAgents(agents);
        mediator.setVisitor(visitor);

        agents.constact("听说便宜机票.....");
        visitor.constact("是的,需要机票吗？");

    }

}

• 优点
  1、 简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，将各个同事类解耦，使系统成为松耦合系统。

  2、 减少了子类的生成。

  3 、 可以减少各同事类的设计与实现。

• 缺点
  由于中介者对象封装了系统中对象之间的相互关系，导致其变得非常复杂，使得系统维护比较困难。

• 适用场景
  1、 系统中对象之间存在比较复杂的引用关系，导致他们之间的依赖关系结构混乱而且难以复用该对象。

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