设计模式 - 中介者模式

概述

       中介者模式（Mediator Pattern）也称为调解者模式或者调停者模式。

定义

       中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而是它们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对对象的行为和协作抽象化。把对象在小尺度的行为上与其他对象的相互作用分开处理。

使用场景

       当对象之间的交互操作很多且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的行为时，同时涉及修改很多其他对象的行为，可采用中介者模式，来解决耦合问题。该模式将对象之间的多对多的关系变成一对多的关系，中介者对象将系统从网状结构变成调停者为中的星形结构，达到降低的复杂性，提高可扩展性。

UML类图

角色介绍：

Mediator:抽象中介者角色，定义了同事对象到对象的接口，一般以抽象类的方式实现。

ConcreteMediator：具体中介者角色，继承于抽象中介者，实现了父类定义的方法，它从具体的同事对象接收消息，像具体同事对象发出命令。

Colleague:抽象同事类角色，定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。

ConcreteColleagueA/B:具体同事类角色，继承于抽象同时类，每个具体同事类都知道本身在小范围内的行为，而不知道它在大范围内的目的。

示例代码

       创建抽象中介者

public abstract class Mediator {

    /**
     * 同事对象改变时通知中介者的方法
     * 在同事对象改变时由中介通知其他的同事对象
     *
     * @param colleague 改变的同事对象
     */
    abstract void changed(Colleague colleague);
}

       创建具体中介者

public class ConcreteMediator extends Mediator {

    Colleague mColleague;
    ColleagueA mColleagueA;
    ColleagueB mColleagueB;

    @Override
    void changed(Colleague colleague) {
        if (colleague instanceof ColleagueA) {
            handleColleagueA();
        } else if (colleague instanceof ColleagueB){
            handleColleagueB();
        }
    }

    private void handleColleagueA() {
        mColleagueA.toast("我是操作者A");
        mColleagueB.toast("我是同事，A告诉我干嘛");
    }
    private void handleColleagueB() {
        mColleagueA.toast("我是同事，B告诉我干嘛");
        mColleagueB.toast("我是操作者B");
    }

    public void setmColleagueA(ColleagueA mColleagueA) {
        this.mColleagueA = mColleagueA;
    }

    public void setmColleagueB(ColleagueB mColleagueB) {
        this.mColleagueB = mColleagueB;
    }
}

       创建抽象同事

public abstract class Colleague {
    Mediator mMediator;

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

    abstract void attend();
}

       创建具体同事A和B

public class ColleagueA extends Colleague {

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

    @Override
    void attend() {
        mMediator.changed(this);
    }

    public void toast(String content) {
        System.out.println(content);
    }
}

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

    @Override
    void attend() {
        mMediator.changed(this);
    }

    public void toast(String content) {
        System.out.println(content);
    }
}

       测试类

public class Test {
    public static void main(String[] args) {
        ConcreteMediator mMediator = new ConcreteMediator();
        ColleagueA mColleagueA = new ColleagueA(mMediator);
        ColleagueB mCOColleagueB = new ColleagueB(mMediator);

        mMediator.setmColleagueA(mColleagueA);
        mMediator.setmColleagueB(mCOColleagueB);

        mColleagueA.attend();

        System.out.println("\n----------------------------\n");

        mCOColleagueB.attend();
    }
}

       Log打印

我是操作者A
我是同事，A告诉我干嘛

----------------------------

我是同事，B告诉我干嘛
我是操作者B