美文网首页
行为型模式——中介者模式

行为型模式——中介者模式

作者: Doooook | 来源:发表于2020-08-30 08:53 被阅读0次

中介者模式(Mediator Pattern):使用中介者模式来集中相关对象之间复杂的沟通和控制方式,使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时,不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

中介者的作用

如下图所示,此图中有6个对象,这些对象既会影响别的对象,又会被别的对象所影响,因此常常叫做同事(Colleague)对象。这些同事对象通过彼此的相互作用形成系统的行为。从图中可以看出,当对象1改变时,除了对象3之外其他所有对象都有可能受到影响;当对象2改变时,所有对象都有可能受到影响。这就是过度耦合的系统。


image.png

通过引入中介者(Mediator),那么同事类之间的关系将变成星型结构。如下图所示,在这个星型结构中,同事对象不再通过直接的联系与另一个对象发生相互作用;相反的,它通过中介者对象与另一个对象发生相互作用。中介者对象的存在保证了对象结构上的稳定,也就是说,系统的结构不会因为新对象的引入造成大量的修改工作。


image.png

实现

image.png
  • Mediator(抽象中介者):抽象中介者定义了参与者的交互方式。在此接口或抽象类中声明的操作与场景相关。
  • ConcreteMediator(具体中介者):它实现了中介者声明的操作。
  • Colleague(抽象同事角色):这是一个抽象类或接口,用于定义需要调解的参与者如何进行交互。
  • ConcreteColleague(具体同事角色):这是实现Colleague接口的具体类。

应用实例

1. 抽象中介者

/**
 * @author: Jay Mitter
 * @date: 2020-08-23 20:54
 * @description: 抽象中介者
 */
public interface Mediator {

    /**
     * 中介者通过此方法来改变同事B
     * @param str
     */
    void aChangedB(String str);

    /**
     * 中介者通过此方法来改变同事A
     * @param str
     */
    void bChangedA(String str);
}

2. 抽象同事类

/**
 * @author: Jay Mitter
 * @date: 2020-08-29 20:57
 * @description: 抽象同事类
 */
public abstract class AbstractColleague {

    /**
     * 同事对象在改变的时候,通知中介者,并传递影响值
     * @param str
     * @param mediator
     */
    public abstract void setString(String str, Mediator mediator);

    /**
     * 同事对象提供一个接口接收中介者传递的影响值
     * @param str
     */
    public abstract void changeString(String str);

}

3. 具体同时类A

/**
 * @author: Jay Mitter
 * @date: 2020-08-29 20:58
 * @description: 具体同事类A
 */
public class ConcreteColleagueA extends AbstractColleague {

    /**
     * 同事A的字符串属性
     */
    private String strAttribute;

    /**
     * 构造函数,构造字符串属性
     * @param strAttribute
     */
    public ConcreteColleagueA(String strAttribute) {
        this.strAttribute = strAttribute;
    }

    /**
     * 改变时,通知中介者改变其他同事
     * @param str
     * @param mediator
     */
    @Override
    public void setString(String str, Mediator mediator) {
        mediator.aChangedB(str);
    }

    @Override
    public void changeString(String str) {
        this.strAttribute = this.strAttribute + "这是同事B对我的影响:" + str;
    }

    public String getStrAttribute() {
        return strAttribute;
    }

    public void setStrAttribute(String strAttribute) {
        this.strAttribute = strAttribute;
    }
}

4. 具体同时类B

/**
 * @author: Jay Mitter
 * @date: 2020-08-29 21:01
 * @description: 具体同事类B
 */
public class ConcreteColleagueB extends AbstractColleague {

    /**
     * 同事B的字符串属性
     */
    private String strAttribute;

    /**
     * 构造函数,构造字符串属性
     * @param strAttribute
     */
    public ConcreteColleagueB(String strAttribute) {
        this.strAttribute = strAttribute;
    }

    @Override
    public void setString(String str, Mediator mediator) {
        mediator.bChangedA(str);
    }

    @Override
    public void changeString(String str) {
        this.strAttribute = this.strAttribute + "这是同事A对我的影响:" + str;
    }

    public String getStrAttribute() {
        return strAttribute;
    }

    public void setStrAttribute(String strAttribute) {
        this.strAttribute = strAttribute;
    }
}

5. 具体中介者类

/**
 * @author: Jay Mitter
 * @date: 2020-08-29 21:03
 * @description: 具体中介者类
 */
public class ConcreteMediator implements Mediator {

    /**
     * 持有并维护同事A
     */
    private ConcreteColleagueA colleagueA;
    /**
     * 持有并维护同事B
     */
    private ConcreteColleagueB colleagueB;

    /**
     * 收到同事A的改变,通知同事B改变
     * @param str
     */
    @Override
    public void aChangedB(String str) {
        colleagueB.changeString(str);
    }

    /**
     * 收到同事B的改变,通知同事A改变
     * @param str
     */
    @Override
    public void bChangedA(String str) {
        colleagueA.changeString(str);
    }

    public ConcreteColleagueA getColleagueA() {
        return colleagueA;
    }

    public void setColleagueA(ConcreteColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public ConcreteColleagueB getColleagueB() {
        return colleagueB;
    }

    public void setColleagueB(ConcreteColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }
}

测试

    /**
     * 行为型模式——中介者模式
     */
    @Test
    public void testBehaviorMediator() {
        // 实例化同事A、B
        ConcreteColleagueA colleagueA = new ConcreteColleagueA("大家好,我是同事A。");
        ConcreteColleagueB colleagueB = new ConcreteColleagueB("大家好,我是同事B。");

        // 同时把同事A、B传入给中介者
        ConcreteMediator mediator = new ConcreteMediator();
        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        // 同事A影响同事B
        System.out.println(colleagueB.getStrAttribute());
        colleagueA.setString("同事A传递给同事B的值", mediator);
        System.out.println(colleagueB.getStrAttribute());

        // 同事B影响同事A
        System.out.println(colleagueA.getStrAttribute());
        colleagueB.setString("同事B传递给同事A的值", mediator);
        System.out.println(colleagueA.getStrAttribute());

    }

打印结果:

大家好,我是同事B。
大家好,我是同事B。这是同事A对我的影响:同事A传递给同事B的值
大家好,我是同事A。
大家好,我是同事A。这是同事B对我的影响:同事B传递给同事A的值

参考:https://blog.csdn.net/jsagacity/article/details/79032608

相关文章

网友评论

      本文标题:行为型模式——中介者模式

      本文链接:https://www.haomeiwen.com/subject/bujjsktx.html