Java-中介者-设计模式（二十一）

说明

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

UML

代码

参考《大话设计模式》实现的基本代码。

抽象同事类

/**
 * @author ctl
 * @date 2021/2/1
 */
public abstract class Colleague {
          
   

    Mediator mediator;

    public Colleague(Mediator mediator) {
          
   
        this.mediator = mediator;
    }
}

具体同事类1

/**
 * @author ctl
 * @date 2021/2/1
 */
public class ConcreteColleague1 extends Colleague {
          
   

    public ConcreteColleague1(Mediator mediator) {
          
   
        super(mediator);
    }

    public void send(String meg) {
          
   
        mediator.send(meg, this);
    }

    public void notify(String msg) {
          
   
        System.out.println(this.getClass().getSimpleName() + "得到信息：" + msg);
    }

}

具体同事类2

/**
 * @author ctl
 * @date 2021/2/1
 */
public class ConcreteColleague2 extends Colleague {
          
   

    public ConcreteColleague2(Mediator mediator) {
          
   
        super(mediator);
    }

    public void send(String meg) {
          
   
        mediator.send(meg, this);
    }

    public void notify(String msg) {
          
   
        System.out.println(this.getClass().getSimpleName() + "得到信息：" + msg);
    }
}

抽象中介者

/**
 * @author ctl
 * @date 2021/2/1
 */
public interface Mediator {
          
   

    void send(String msg, Colleague colleague);
}

具体中介者

/**
 * @author ctl
 * @date 2021/2/1
 */
public class ConcreteMediator implements Mediator {
          
   

    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    @Override
    public void send(String msg, Colleague colleague) {
          
   
        if (colleague instanceof ConcreteColleague1) {
          
   
            colleague2.notify(msg);
        } else if (colleague instanceof ConcreteColleague2) {
          
   
            colleague1.notify(msg);
        }
    }

    public void setColleague1(ConcreteColleague1 colleague1) {
          
   
        this.colleague1 = colleague1;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
          
   
        this.colleague2 = colleague2;
    }
}

测试类

/**
 * @author ctl
 * @date 2021/2/1
 */
public class MediatorMain {
          
   

    public static void main(String[] args) {
          
   
        ConcreteMediator mediator = new ConcreteMediator();

        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.send("hello im ConcreteColleague1");
        colleague2.send("hello im ConcreteColleague2");
    }
}

结果

总结

但由于中介者将行为控制进行了集中化，中介者的复杂性也就随着对象交互的复杂性而来了。优缺点都是中介者本身，所以是否要使用还是要考虑清楚。

中介者模式一般应用于一组对象定义良好但是要通过复杂的方式来进行通信的场合。