行为型设计模式之中介者模式

Posted 2022-09-29

中介者模式

应用场景

当多个类相互耦合，形成了网状结构，则可以考虑使用中介者模式进行优化。

1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。

2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

飞行器驾驶员之间不会通过相互沟通来决定下一架降落的飞机。 所有沟通都通过控制塔台进行。

主要角色

1.抽象中介者(Mediator)

2.具体中介者(ConcreteMediator)

3.抽象同事类(Colleague)

4.具体同事类(ConcreteColleague)

优缺点

优点：

1.减少类间依赖，将多对多依赖转化成了一对多，降低了类间耦合；

2.类间各司其职，符合迪米特法则。

缺点：

1.中介者模式中将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

基本使用

创建抽象中介者

public abstract class Mediator 
    protected ConcreteColleagueA colleagueA;
    protected ConcreteColleagueB colleagueB;

    public void setColleageA(ConcreteColleagueA colleague) 
        this.colleagueA = colleague;
    

    public void setColleageB(ConcreteColleagueB colleague) 
        this.colleagueB = colleague;
    

    // 中介者业务逻辑
    public abstract void transferA();

    public abstract void transferB();

创建具体中介者

public class ConcreteMediator extends Mediator 
    /**
     * 由具体同事类A，向具体同事对象B发出指令
     */
    @Override
    public void transferA() 
        this.colleagueB.selfMethodB();
    

    /**
     * 由具体同事类B，向具体同事对象A发出指令
     */
    @Override
    public void transferB() 
        this.colleagueA.selfMethodA();
    

创建抽象同事类

public abstract class Colleague 
    protected Mediator mediator;

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

创建具体同事类

public class ConcreteColleagueA extends Colleague 
    public ConcreteColleagueA(Mediator mediator) 
        super(mediator);
        this.mediator.setColleageA(this);
    

    /**
     * 自有方法
     */
    public void selfMethodA() 
        System.out.println( this.getClass().getSimpleName()+ "收到中介协作通知，selfMethodA自有方法执行");
    

    /**
     * 依赖方法
     */
    public void depMethodA() 
        System.out.println( this.getClass().getSimpleName()+ " depMethodA通知中介者进行转发协作");
        // 中介者进行转发协作
        this.mediator.transferA();
    

public class ConcreteColleagueB extends Colleague 
    public ConcreteColleagueB(Mediator mediator) 
        super(mediator);
        this.mediator.setColleageB(this);
    

    /**
     * 自有方法
     */
    public void selfMethodB() 
        System.out.println(this.getClass().getSimpleName() + "收到中介协作通知，selfMethodB自有方法执行");
    

    /**
     * 依赖方法
     */
    public void depMethodB() 
        System.out.println(this.getClass().getSimpleName() + " depMethodB通知中介者进行转发协作");
        // 中介者进行转发协作
        this.mediator.transferB();
    

客户端执行

    public static void main(String[] args) 
        // 创建抽象中介者
        Mediator mediator = new ConcreteMediator();
        // 具体同事类
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        // 中介者进行转发协作,A转发给B
        colleagueA.depMethodA();
        System.out.println("-------------------------");
        // 中介者进行转发协作,B转发给A
        colleagueB.depMethodB();
    

ConcreteColleagueA depMethodA通知中介者进行转发协作
ConcreteColleagueB收到中介协作通知，selfMethodB自有方法执行
-------------------------
ConcreteColleagueB depMethodB通知中介者进行转发协作
ConcreteColleagueA收到中介协作通知，selfMethodA自有方法执行