标签：编程   new   作用   abs   pattern   自己的   需要   没有   etc   

中介者模式

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中介者模式

标签：编程   new   作用   abs   pattern   自己的   需要   没有   etc   

原文地址：https://www.cnblogs.com/jeff-chang/p/13515033.html