Java设计模式(二十二)----调停者模式

调停者模式
定义:调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时,不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

为什么需要调停者
如下图所示,这个示意图中有大量的对象,这些对象既会影响别的对象,又会被别的对象所影响,因此常常叫做同事(Colleague)对象。这些同事对象通 过彼此的相互作用形成系统的行为。从图中可以看出,几乎每一个对象都需要与其他的对象发生相互作用,而这种相互作用表现为一个对象与另一个对象的直接耦 合。这就是过度耦合的系统。

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

如果没有主板
大家都知道,电脑里面各个配件之间的交互,主要是通过主板来完成的。如果电脑里面没有了主板,那么各个配件之间就必须自行相互交互,以互相传送数据。而且由于各个配件的接口不同,相互之间交互时,还必须把数据接口进行转换才能匹配上。

 所幸是有了主板,各个配件的交互完全通过主板来完成,每个配件都只需要和主板交互,而主板知道如何跟所有的配件打交道,这样就简单多了。

调停者模式的结构

调停者模式的示意性类图如下所示:
  

  
  调停者模式包括以下角色:
  ●抽象调停者(Mediator)角色:定义出同事对象到调停者对象的接口,其中主要方法是一个(或多个)事件方法。
  ●具体调停者(ConcreteMediator)角色:实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类,并负责具体的协调各同事对象的交互关系。
  ●抽象同事类(Colleague)角色:定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。
  ●具体同事类(ConcreteColleague)角色:所有的具体同事类均从抽象同事类继承而来。实现自己的业务,在需要与其他同事通信的时候,就与持有的调停者通信,调停者会负责与其他的同事交互。

抽象调停者类

public interface Mediator {
    /**
     * 同事对象在自身改变的时候来通知调停者的方法
     * 让调停者去负责相应的与其他同事对象的交互
     */
    public void changed(Colleague c);
}

具体调停者类

public class ConcreteMediator implements Mediator {
    //持有并维护同事A
    private ConcreteColleagueA colleagueA;
    //持有并维护同事B
    private ConcreteColleagueB colleagueB;    

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

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

    @Override
    public void changed(Colleague c) {
        /**
         * 某一个同事类发生了变化,通常需要与其他同事交互
         * 具体协调相应的同事对象来实现协作行为
         */
    }

}

抽象同事类

public abstract class Colleague {
    //持有一个调停者对象
    private Mediator mediator;
    /**
     * 构造函数
     */
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
    /**
     * 获取当前同事类对应的调停者对象
     */
    public Mediator getMediator() {
        return mediator;
    }

}

具体同事类

public class ConcreteColleagueA extends Colleague {

    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }
    /**
     * 示意方法,执行某些操作
     */
    public void operation(){
        //在需要跟其他同事通信的时候,通知调停者对象
        getMediator().changed(this);
    }
}
public class ConcreteColleagueB extends Colleague {

    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }
    /**
     * 示意方法,执行某些操作
     */
    public void operation(){
        //在需要跟其他同事通信的时候,通知调停者对象
        getMediator().changed(this);
    }
}

具体案例
我们使用一个例子来说明一下什么是同事类:有两个类A和B,类中各有一个数字,并且要保证类B中的数字永远是类A中数字的100倍。也就是说,当修改类A 的数时,将这个数字乘以100赋给类B,而修改类B时,要将数除以100赋给类A。类A类B互相影响,就称为同事类。代码如下:

package Mediator;

abstract class AbstractColleague {
    protected int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    // 注意这里的参数不再是同事类,而是一个中介者
    public abstract void setNumber(int number, AbstractMediator am);
}

class ColleagueA extends AbstractColleague {

    public void setNumber(int number, AbstractMediator am) {
        this.number = number;
        am.AaffectB();
    }
}

class ColleagueB extends AbstractColleague {

    @Override
    public void setNumber(int number, AbstractMediator am) {
        this.number = number;
        am.BaffectA();
    }
}

abstract class AbstractMediator {
    protected AbstractColleague A;
    protected AbstractColleague B;

    public AbstractMediator(AbstractColleague a, AbstractColleague b) {
        A = a;
        B = b;
    }

    public abstract void AaffectB();

    public abstract void BaffectA();

}

class Mediator extends AbstractMediator {

    public Mediator(AbstractColleague a, AbstractColleague b) {
        super(a, b);
    }

    // 处理A对B的影响
    public void AaffectB() {
        int number = A.getNumber();
        B.setNumber(number * 100);
    }

    // 处理B对A的影响
    public void BaffectA() {
        int number = B.getNumber();
        A.setNumber(number / 100);
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractColleague collA = new ColleagueA();
        AbstractColleague collB = new ColleagueB();

        AbstractMediator am = new Mediator(collA, collB);

        System.out.println("==========通过设置A影响B==========");
        collA.setNumber(1000, am);
        System.out.println("collA的number值为:" + collA.getNumber());
        System.out.println("collB的number值为A的10倍:" + collB.getNumber());

        System.out.println("==========通过设置B影响A==========");
        collB.setNumber(1000, am);
        System.out.println("collB的number值为:" + collB.getNumber());
        System.out.println("collA的number值为B的0.1倍:" + collA.getNumber());

    }
}

结果:
==========通过设置A影响B==========
collA的number值为:1000
collB的number值为A的10倍:100000
==========通过设置B影响A==========
collB的number值为:1000
collA的number值为B的0.1倍:10

调停者模式的优点
  ●松散耦合
  调停者模式通过把多个同事对象之间的交互封装到调停者对象里面,从而使得同事对象之间松散耦合,基本上可以做到互补依赖。这样一来,同事对象就可以独立地变化和复用,而不再像以前那样“牵一处而动全身”了。
  ●集中控制交互
  多个同事对象的交互,被封装在调停者对象里面集中管理,使得这些交互行为发生变化的时候,只需要修改调停者对象就可以了,当然如果是已经做好的系统,那么就扩展调停者对象,而各个同事类不需要做修改。
  ●多对多变成一对多
  没有使用调停者模式的时候,同事对象之间的关系通常是多对多的,引入调停者对象以后,调停者对象和同事对象的关系通常变成双向的一对多,这会让对象的关系更容易理解和实现。
调停者模式的缺点
  调停者模式的一个潜在缺点是,过度集中化。如果同事对象的交互非常多,而且比较复杂,当这些复杂性全部集中到调停者的时候,会导致调停者对象变得十分复杂,而且难于管理和维护。

以上内容来自平时所看书籍和网络资源整理测试所得,如有不完善之处,欢迎指正!

时间: 2024-12-10 09:09:34

Java设计模式(二十二)----调停者模式的相关文章

Java设计模式(十四)----模板方法模式

模板方法模式 一.概述 二.结构 三.具体案例 四.优缺点和设计思想 一.概述 模板方法模式是类的行为模式.准备一个抽象类,将部分逻辑以具体方法以及具体构造函数的形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑.不同的子类可以以不同的方式实现这些抽象方法,从而对剩余的逻辑有不同的实现.这就是模板方法模式的用意 二.结构 模板方法模式是所有模式中最为常见的几个模式之一,是基于继承的代码复用的基本技术. 模板方法模式需要开发抽象类和具体子类的设计师之间的协作.一个设计师负责给出一个算法的轮廓和

Java设计模式(十九)----备忘录模式

备忘录模式 一. 概念 二. 结构 三. 分类 1."白箱"备忘录模式的实现 2."黑箱"备忘录模式的实现 3."多重"检查点 4."自述历史"模式 引子 我们在编程的时候,经常需要保存对象的中间状态,当需要的时候,可以恢复到这个状 态.比如,我们使用Eclipse进行编程时,假如编写失误(例如不小心误删除了几行代码),我们希望返回删除前的状态,便可以使用Ctrl+Z来进行返 回.下象棋的时候,可以反悔.这时我们便可以使用备忘

Java设计模式(十八)----命令模式

命令模式 一. 概念 二. 结构 三. 具体案例 四. 宏命令 五. 命令模式优点 引子 在程序设计中,经常设计到一个对象需要请求另外一个对象调用其方法达到某种目的,如果请求这不希望或不直接和被请求者打交道,既请求者不包含被请求者的引 用,那么就可以使用命令模式.例如在军队中,指挥官请求三连偷袭敌人,但是指挥官不希望或无法直接与三连取得联系,那么可以将该请求形成一个命令,该命令 的核心是让三连偷袭敌人.只要能让该命令被执行,就会实现偷袭敌人的目的. 命令模式是关于怎样处理一个对象请求到另一个对象

云计算设计模式(十二)——索引表模式

云计算设计模式(十二)--索引表模式 创建索引过的被查询条件经常被引用的数据存储等领域.这种模式可以通过允许应用程序更快速地定位数据来从数据存储中检索提高查询性能. 背景和问题 许多数据存储通过使用主键组织为实体的集合的数据.应用程序可以使用此键来查找和检索数据.图1显示了一个数据存储区保持顾客的信息的例子.主键是客户ID. 图1  - 按主键组织的客户信息(客户ID) 而主键是该取基于该关键字的值的数据的查询宝贵的,应用程序可能不能够使用主键是否需要基于其它字段来检索数据.在顾客例如,应用程序

云计算设计模式(二十二)——静态内容托管模式

云计算设计模式(二十二)--静态内容托管模式 部署静态内容到一个基于云的存储服务,可以直接向客户提供这些.这个模式可以减少潜在的昂贵的计算实例的需求. 景和问题 Web应用程序通常包括静态内容的一些元素.此静态内容可以包括HTML页面和诸如图像和可用到客户端的文件的其他资源,无论是作为一个HTML页的一部分(如嵌入式图像,样式表和客户端JavaScript文件)或作为单独的下载(如PDF文档). 尽管Web服务器以及调整通过有效的动态执行页代码和输出缓存优化的要求,他们仍然必须处理请求下载静态内

JAVA之旅(二十二)——Map概述,子类对象特点,共性方法,keySet,entrySet,Map小练习

JAVA之旅(二十二)--Map概述,子类对象特点,共性方法,keySet,entrySet,Map小练习 继续坚持下去吧,各位骚年们! 事实上,我们的数据结构,只剩下这个Map的知识点了,平时开发中,也是能看到他的,所以还是非常值得去学习的一个知识点的,我们直接开车了 一.Map概述 泛型< k,v> 键值对,映射关系 基本特点 该集合存储键值对,是一对一对往里存,而且要保证键的唯一性 1.添加 put(key ,values) putAll() 2.删除 clear() remove(ob

C#开发WPF/Silverlight动画及游戏系列教程(Game Course):(二十二)

C#开发WPF/Silverlight动画及游戏系列教程(Game Course):(二十二)重构 – 让代码插上翅膀自由飞翔 上一节,我将游戏地图模式进行了一次重大的变动,这在实际开发中意味着项目大规模重置,虽然表面上显得游刃有余,仅仅一个AllMove()方法的改变即实现了完美转型,这全得归功于前20节所搭建起的相对高度可扩展平台.但是,随着开发不断深入,我慢慢的感到些许的不安,因为代码上的日益松散与结构的渐渐稀疏如同Windows系统的磁盘碎片与日俱增,未来维护时的烦琐与痛心疾首已历历在目

Android简明开发教程二十二:使用资源Resources

在前面的例子中,我们忽略了一个重要的原则,在代码和Layout中,直接使用了字符串常量,比如: <Button android:text="Pattern" android:id="@+id/btnPattern" android:layout_width="wrap_content" android:textColor="@color/black" android:checked="true" an

Windows 8风格应用开发入门 二十二 MessageDialog

MessageDialog概述 MessageDialog指的就是对话框. 对话框的命令栏中最多包含三个命令.如果我们指定任何命令,将会有一个默认命令添加到对话框中,目的是关闭对话框. 对话框弹出后界面中所有元素将在对话框下面显示,并且将会阻塞任何触摸事件直到用户进行响应对话框. 另外对话框应该尽量少用. 注意:Windows 8风格应用中取消了MessageBox对象,取而代之的是MessageDialog对象. MessageDialog常用属性和方法 MessageDialog类包含两类构

设计模式(十)享元模式Flyweight(结构型)

设计模式(十)享元模式Flyweight(结构型) 说明: 相对于其它模式,Flyweight模式在PHP实现似乎没有太大的意义,因为PHP的生命周期就在一个请求,请求执行完了,php占用的资源都被释放.我们只是为了学习而简单做了介绍. 1. 概述 面向对象技术可以很好地解决系统一些灵活性或可扩展性或抽象性的问题,但在很多情况下需要在系统中增加类和对象的个数.当对象数量太多时,将导致运行代价过高,带来性能下降等问题.比如: 例子1:图形应用中的图元等对象.字处理应用中的字符对象等. 2.解决方案