设计模式——终结者模式

中介者模式

@author lisiwen

@createTime 2020/01/08

​ **中介者模式(Mediator)：**用一个中介者对象来封装一系列的对象交互。中介者使各个对象不需要显示地互相引用，从而使其耦合松散，而且可以独立的改变他们之间的交互。

代码示例

Colleague.java

/**
 * @ProjectName: designpattern
 * @ClassName: Colleague
 * @Description: 抽象同事类
 * @Author: lisiwen
 * @Date: 2020/1/8 8:40
 **/
abstract class Colleague {
     
    protected Mediator mediator;

    /**
     * @Description 构造方法得到中介者对象
     * @Date 2020/1/8 8:42
     * @param mediator
     * @Return
     **/
    public Colleague(Mediator mediator){
     
        this.mediator=mediator;
    }

    /**
     * @Description 发送消息的抽象方法
     * @Date 2020/1/8 8:53
     * @param message
     * @Return void
     **/
    abstract void send(String message);

    /**
     * @Description 接收消息之后行为的抽象方法
     * @Date 2020/1/8 8:53
     * @param message
     * @Return void
     **/
    abstract void notify(String message);
}

ConcreteColleague1.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteColleague1
 * @Description: 同事对象1
 * @Author: lisiwen
 * @Date: 2020/1/8 8:43
 **/
public class ConcreteColleague1 extends Colleague {
     
    /**
     * @param mediator
     * @Description 构造方法得到中介者对象
     * @Date 2020/1/8 8:42
     * @Return
     **/
    public ConcreteColleague1(Mediator mediator) {
     
        super(mediator);
    }

    @Override
    public void send(String message) {
     
        mediator.send(message, this);
    }

    @Override
    public void notify(String message) {
     
        System.out.println("同事1得到消息:" + message);
    }
}

ConcreteColleague2.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteColleague2
 * @Description: 同事对象2
 * @Author: lisiwen
 * @Date: 2020/1/8 8:43
 **/
public class ConcreteColleague2 extends Colleague {
     
    /**
     * @param mediator
     * @Description 构造方法得到中介者对象
     * @Date 2020/1/8 8:42
     * @Return
     **/
    public ConcreteColleague2(Mediator mediator) {
     
        super(mediator);
    }

    @Override
    public void send(String message) {
     
        mediator.send(message, this);
    }

    @Override
    public void notify(String message) {
     
        System.out.println("同事2得到消息:" + message);
    }
}

Mediator.java

/**
 * @ProjectName: designpattern
 * @ClassName: Mediator
 * @Description: 抽象中介者接口
 * @Author: lisiwen
 * @Date: 2020/1/8 8:39
 **/
interface Mediator {
     
    /**
     * @Description 定义一个发送消息的接口，得到同事对象和发送信息
     * @Date 2020/1/8 8:39
     * @param message
     * @param colleague
     * @Return void
     **/
    void send(String message,Colleague colleague);
}

ConcreteMediator.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteMediator
 * @Description: 具体中介者类
 * @Author: lisiwen
 * @Date: 2020/1/8 8:42
 **/
public class ConcreteMediator implements Mediator {
     
    private ConcreteColleague1 concreteColleague1;
    private ConcreteColleague2 concreteColleague2;
    public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
     
        this.concreteColleague1 = concreteColleague1;
    }

    public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
     
        this.concreteColleague2 = concreteColleague2;
    }

    @Override
    public void send(String message, Colleague colleague) {
     
        if (colleague == concreteColleague1) {
     
            concreteColleague2.notify(message);
        } else {
     
            concreteColleague1.notify(message);
        }
    }

}

Main.java

/**
 * @ProjectName: designpattern
 * @ClassName: Main
 * @Description: 客户端方法
 * @Author: lisiwen
 * @Date: 2020/1/8 8:48
 **/
public class Main {
     
    public static void main(String[] args) {
     
        ConcreteMediator concreteMediator=new ConcreteMediator();
        //让两个具体同事类人数中介者对象
        ConcreteColleague1 concreteColleague1=new ConcreteColleague1(concreteMediator);
        ConcreteColleague2 concreteColleague2=new ConcreteColleague2(concreteMediator);

        //让这接着认识各个具体同事类对象
        concreteMediator.setConcreteColleague1(concreteColleague1);
        concreteMediator.setConcreteColleague2(concreteColleague2);

        //具体同事类对象的发送消息都是通过中介者转发
        concreteColleague1.send("你在干什么？");
        concreteColleague2.send("我不想告诉你！");
    }
}
//控制台输出
同事2得到消息:你在干什么？
同事1得到消息:我不想告诉你！

中介者模式优缺点

​ 中介者模式很容易在系统中应用，也很容易在系统中误用，当系统出现了‘多对多’交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理。

优点：

1. Mediator的出现减少了各个Colleague的耦合，使得可以独立的改变和复用各个Colleague和Mediator；
2. 又与吧对象如何写作进行了抽象，将中介者作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到了他们之间的交互上来，也就是站在一个更宏观的角度去看待系统；

缺点：

1. 又与ConcreteMediator控制了集中化，于是就把交互复杂性变味了中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂。

应用场合

​ 中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合。