MediatorPattern中介者模式

中介者模式

1.定义

使用一个中介对象封装一系列的对象交互,中介者使用对象不需要显式的相互作用,从而实降现低耦合度,且可以独立改变被封装的一些列对象之间的交互。

中介者模式也叫做调停者模式:对象之间的依赖就像战争,很混乱,加入一个中心,所有对象都和中心交流,接受中心的调停处理。

中介者模式通常有4个角色

AbstractColleague抽象同事类:抽象中介者角色。指定一个中介者用于与其它同事之间的通信。

public abstract class AbstractColleague {

    protected AbstractMediator mediator;

    public AbstractColleague(AbstractMediator mediator) {
        this.mediator = mediator;
    }
}

AbstractMediator抽象类:抽象中介者角色。定义统一的接口,用于各同事角色之间的通信。

public abstract class AbstractMediator {

    protected ColleagueOne colleagueOne;

    protected ColleagueTwo colleagueTwo;

    public ColleagueOne getColleagueOne() {
        return colleagueOne;
    }

    public ColleagueTwo getColleagueTwo() {
        return colleagueTwo;
    }

    public void setColleagueOne(ColleagueOne colleagueOne) {
        this.colleagueOne = colleagueOne;
    }

    public void setColleagueTwo(ColleagueTwo colleagueTwo) {
        this.colleagueTwo = colleagueTwo;
    }

    public abstract void executeOne();

    public abstract void executeTwo();
}

Colleague类具体同事类:同事角色。每一个同事角色都知道中介者角色,每一个同事角色的行为分为两种:一种是自身的行为,用来改变自身的状态或处理自身的业务逻辑,并且与其它同事和中介者没有任何依赖关系,叫做自发行为。另一种是必须依赖中介者才能完成的行为,叫做依赖方法。

public class ColleagueOne extends AbstractColleague {

    public ColleagueOne(AbstractMediator mediator) {
        super(mediator);
    }

    /**
     * 自发行为
     */
    public void selfMethodOne() {
        // 处理自己的业务逻辑
        System.out.println("ColleagueOne的自有方法");
    }

    /**
     * 依赖行为
     */
    public void depMethodOne() {
        // 处理自己的业务逻辑
        System.out.println("ColleagueOne的依赖方法");

        // 委托中介者处理
        super.mediator.executeOne();
    }
}

public class ColleagueTwo extends AbstractColleague {

    public ColleagueTwo(AbstractMediator mediator) {
        super(mediator);
    }

    /**
     * 自发行为
     */
    public void selfMethodTwo() {
        // 处理自己的业务逻辑
        System.out.println("ColleagueTwo的自有方法");
    }

    /**
     * 依赖行为
     */
    public void depMethodTwo() {
        // 处理自己的业务逻辑
        System.out.println("ColleagueTwo的依赖方法");

        // 委托中介者处理
        super.mediator.executeTwo();
    }
}

Mediator类:通用中介者角色。协调各同事角色实现协作行为,必须依赖各个同事角色。

public class Mediator extends AbstractMediator {

    @Override
    public void executeOne() {
        super.colleagueOne.selfMethodOne();
        super.colleagueTwo.selfMethodTwo();
    }

    @Override
    public void executeTwo() {
        super.colleagueTwo.selfMethodTwo();
        super.colleagueOne.selfMethodOne();
    }
}

场景类

public class Client {

    public static void main(String[] args) {
        // 定义中介者
        AbstractMediator mediator = new Mediator();

        // 定义同事类
        ColleagueOne colleagueOne = new ColleagueOne(mediator);
        ColleagueTwo colleagueTwo = new ColleagueTwo(mediator);

        // 中介者注入同事类
        mediator.setColleagueOne(colleagueOne);
        mediator.setColleagueTwo(colleagueTwo);

        colleagueOne.depMethodOne();

        colleagueTwo.depMethodTwo();
    }
}

2.应用

2.1 优点

  • 减少类之间的依赖,降低类之间的耦合度

2.2 缺点

  • 中介者会过于膨胀,且逻辑复杂

2.3 使用场景

在面向对象的编程中,对象及对象之间必然会存在依赖关系,存在即合理,不一定有依赖关系则使用中介者模式。中介者模式适用于多个对象之间紧密耦合的情况,类图中出现了蜘蛛网状结构。使用中介者模式有利于将蜘蛛网状结构梳理为星型结构。

  • 调度中心
  • 媒体网关
  • 中介服务

你可能感兴趣的:(MediatorPattern中介者模式)