学习设计模式

中介者模式

一丶定义

　　定义一个中介者对象, 封装一系列对象的交互关系, 使得各对象不必显示的相互引用, 从而使其耦合松散, 而且可以独立的改变它们的交互

 

二丶理解

 　　各对象显式地持有对方引用, 用于对象之间的交互, 交互关系形成网状结构, 不利于系统维护以及开发人员的理解. 这时可以定义一个中介者对象, 封装注册各对象的引用, 以及完成对象之间的交互操作. 同事对象之间不能直接交互, 它们之间的交互, 需要委托给中介者对象完成, 即 同事对象除了完成自己本身的操作之外, 只和中介者打交道(符合最少知识原则), 如此一来, 交互关系将由复杂的网状结构变成星型结构.  方便系统维护以及开发人员的理解. 

　　关键点在于同事对象之间不能直接交互, 交互依赖于中介者完成, 中介者注册管理各同事对象的引用, 以及负责转发消息, 实现他们之间的交互

　　1) Mediator 抽象中介者

　　　　用于定义统一的接口, 用于各同事对象之间的交互

　　2) Concrete Mediator 具体中介者

　　　　具体中介者持有各同事对象的引用, 负责协调各同事对象的行为以完成协作, 因此具体中介者必须依赖具体同事对象(不符合依赖倒置原则)

　　3) Colleague 同事角色

　　　　每个同事角色都知道中介者对象, 而且与其他同事角色通信的时候,都通过中介者协作完成

　　每个同事角色都有两种行为:

　　　　a. 自发行为: 同事本身的行为, 如修改自身的状态, 与其他同事或者中介者没有任何的依赖.

　　　　b. 依赖方法: 必须依赖中介者才能完成的行为.

 

三丶示例

 　　抽象中介者

public abstract class Mediator {

    //中介者记录各具体同事类的引用, 用于交互
    // 也可以是集合类记录,如 List, Map
    protected ConcreteColleague1 colleague1;
    protected ConcreteColleague2 colleague2;


    // ------------------------- 因为中介者可以有部分同事类, 所以使用setter, getter 注入同事类

    public ConcreteColleague1 getColleague1() {
        return colleague1;
    }

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

    public ConcreteColleague2 getColleague2() {
        return colleague2;
    }

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



    // ------------------------------------------ 具体同事类依赖中介者的方法
    //这种方法其实可以精简成通用的发放 sendMessage(String toColleague, message)
    public abstract void sendMessageToColleague1(String message);
    //
    public abstract void sendMessageToColleague2(String message);


}

 　　具体中介者:

public class ConcreteMediator extends  Mediator{  // 具体中介者一般只有一个, 即通用中介者

    @Override
    public void sendMessageToColleague1(String message) {
        super.colleague1.receiveMessage(message);
    }

    @Override
    public void sendMessageToColleague2(String message) {
        super.colleague2.receiveMessage(message);
    }
}

　　抽象同事角色:

public abstract class Colleague {
    protected Mediator mediator;

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

　　具体同事角色1:

public class ConcreteColleague1 extends Colleague {


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

    // ---------- self-method
    public void selfMethod(){
        System.out.println("colleague1: 自发行为...");
    }

    public void receiveMessage(String message){
        System.out.println("colleague1收到消息: "+message);
    }

    // ---------- dependency-method
    public void sendMessageToColleague2(String message){ // 同事类之间不能直接交互, 同事类不能完成的工作委托给中介者完成
        super.mediator.sendMessageToColleague2(message);
    }

}

　　具体同事2:

public class ConcreteColleague2 extends Colleague{

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

    // ---------- self-method
    public void selfMethod(){
        System.out.println("colleague2: 自发行为...");
    }

    public void receiveMessage(String message){
        System.out.println("colleague2收到消息: "+message);
    }

    // ---------- dependency-method
    public void sendMessageToColleague1(String message){ // 同事类之间不能直接交互, 同事类不能完成的工作委托给中介者完成
        super.mediator.sendMessageToColleague1(message);
    }

}

　　具体同事3:

public class ConcreteColleague3 extends Colleague {
    public ConcreteColleague3(Mediator mediator) {
        super(mediator);
    }

    public void selfMethod(){
        System.out.println("colleague3: 自发行为...");
    }

    public void sendMessageToColleague1(String message){
        super.mediator.sendMessageToColleague1(message);
    }

    public void sendMessageToColleague2(String message){
        super.mediator.sendMessageToColleague2(message);
    }
}

　　场景类:

public class Client {

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

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


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


        colleague1.selfMethod();
        colleague1.sendMessageToColleague2("来自colleague1的贺电...");

        colleague2.selfMethod();
        colleague2.sendMessageToColleague1("来自colleague2的贺电...");


        // 之后新增一个colleague3, 与其他同事类交互很清晰
        ConcreteColleague3 colleague3=new ConcreteColleague3(mediator);
        colleague3.selfMethod();
        colleague3.sendMessageToColleague1("来自colleague3的贺电...");
        colleague3.sendMessageToColleague2("来自colleague3的贺电...");

    }

}

　　

　　输出结果:

colleague1: 自发行为...
colleague2收到消息: 来自colleague1的贺电...
colleague2: 自发行为...
colleague1收到消息: 来自colleague2的贺电...
colleague3: 自发行为...
colleague1收到消息: 来自colleague3的贺电...
colleague2收到消息: 来自colleague3的贺电...

 　　完整源码:  中介者模式

 学习资料:

　　<设计模式之禅>

　　中介者模式|菜鸟教程

 　　中介者模式(详解版)