原文出处:http://blog.csdn.net/zhengzhb/article/details/7430098

 

定义:用一个中介者对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使耦合松散,而且可以独立地改变它们之间的交互。

类型:行为类模式

类图:

中介者模式的结构

中介者模式又称为调停者模式,从类图中看,共分为3部分:

  • 抽象中介者:定义好同事类对象到中介者对象的接口,用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法,并由子类去实现。
  • 中介者实现类:从抽象中介者继承而来,实现抽象中介者中定义的事件方法。从一个同事类接收消息,然后通过消息影响其他同时类。
  • 同事类:如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对象称为同事类。在类图中,同事类只有一个,这其实是现实的省略,在实际应用中,同事类一般由多个组成,他们之间相互影响,相互依赖。同事类越多,关系越复杂。并且,同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中,同事类之间必须通过中介者才能进行消息传递。

为什么要使用中介者模式

一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下图中,有六个同事类对象,假如对象1发生变化,那么将会有4个对象受到影响。如果对象2发生变化,那么将会有5个对象受到影响。也就是说,同事类之间直接关联的设计是不好的。

如果引入中介者模式,那么同事类之间的关系将变为星型结构,从图中可以看到,任何一个类的变动,只会影响的类本身,以及中介者,这样就减小了系统的耦合。一个好的设计,必定不会把所有的对象关系处理逻辑封装在本类中,而是使用一个专门的类来管理那些不属于自己的行为。

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

  1. abstract class AbstractColleague {
  2. protected int number;
  3. public int getNumber() {
  4. return number;
  5. }
  6. public void setNumber(int number){
  7. this.number = number;
  8. }
  9. //抽象方法,修改数字时同时修改关联对象
  10. public abstract void setNumber(int number, AbstractColleague coll);
  11. }
  12. class ColleagueA extends AbstractColleague{
  13. public void setNumber(int number, AbstractColleague coll) {
  14. this.number = number;
  15. coll.setNumber(number*100);
  16. }
  17. }
  18. class ColleagueB extends AbstractColleague{
  19. public void setNumber(int number, AbstractColleague coll) {
  20. this.number = number;
  21. coll.setNumber(number/100);
  22. }
  23. }
  24. public class Client {
  25. public static void main(String[] args){
  26. AbstractColleague collA = new ColleagueA();
  27. AbstractColleague collB = new ColleagueB();
  28. System.out.println("==========设置A影响B==========");
  29. collA.setNumber(1288, collB);
  30. System.out.println("collA的number值:"+collA.getNumber());
  31. System.out.println("collB的number值:"+collB.getNumber());
  32. System.out.println("==========设置B影响A==========");
  33. collB.setNumber(87635, collA);
  34. System.out.println("collB的number值:"+collB.getNumber());
  35. System.out.println("collA的number值:"+collA.getNumber());
  36. }
  37. }

上面的代码中,类A类B通过直接的关联发生关系,假如我们要使用中介者模式,类A类B之间则不可以直接关联,他们之间必须要通过一个中介者来达到关联的目的。

  1. abstract class AbstractColleague {
  2. protected int number;
  3. public int getNumber() {
  4. return number;
  5. }
  6. public void setNumber(int number){
  7. this.number = number;
  8. }
  9. //注意这里的参数不再是同事类,而是一个中介者
  10. public abstract void setNumber(int number, AbstractMediator am);
  11. }
  12. class ColleagueA extends AbstractColleague{
  13. public void setNumber(int number, AbstractMediator am) {
  14. this.number = number;
  15. am.AaffectB();
  16. }
  17. }
  18. class ColleagueB extends AbstractColleague{
  19. @Override
  20. public void setNumber(int number, AbstractMediator am) {
  21. this.number = number;
  22. am.BaffectA();
  23. }
  24. }
  25. abstract class AbstractMediator {
  26. protected AbstractColleague A;
  27. protected AbstractColleague B;
  28. public AbstractMediator(AbstractColleague a, AbstractColleague b) {
  29. A = a;
  30. B = b;
  31. }
  32. public abstract void AaffectB();
  33. public abstract void BaffectA();
  34. }
  35. class Mediator extends AbstractMediator {
  36. public Mediator(AbstractColleague a, AbstractColleague b) {
  37. super(a, b);
  38. }
  39. //处理A对B的影响
  40. public void AaffectB() {
  41. int number = A.getNumber();
  42. B.setNumber(number*100);
  43. }
  44. //处理B对A的影响
  45. public void BaffectA() {
  46. int number = B.getNumber();
  47. A.setNumber(number/100);
  48. }
  49. }
  50. public class Client {
  51. public static void main(String[] args){
  52. AbstractColleague collA = new ColleagueA();
  53. AbstractColleague collB = new ColleagueB();
  54. AbstractMediator am = new Mediator(collA, collB);
  55. System.out.println("==========通过设置A影响B==========");
  56. collA.setNumber(1000, am);
  57. System.out.println("collA的number值为:"+collA.getNumber());
  58. System.out.println("collB的number值为A的10倍:"+collB.getNumber());
  59. System.out.println("==========通过设置B影响A==========");
  60. collB.setNumber(1000, am);
  61. System.out.println("collB的number值为:"+collB.getNumber());
  62. System.out.println("collA的number值为B的0.1倍:"+collA.getNumber());
  63. }
  64. }

虽然代码比较长,但是还是比较容易理解的,其实就是把原来处理对象关系的代码重新封装到一个中介类中,通过这个中介类来处理对象间的关系。

中介者模式的优点

  • 适当地使用中介者模式可以避免同事类之间的过度耦合,使得各同事类之间可以相对独立地使用。
  • 使用中介者模式可以将对象间一对多的关联转变为一对一的关联,使对象间的关系易于理解和维护。
  • 使用中介者模式可以将对象的行为和协作进行抽象,能够比较灵活的处理对象间的相互作用。

适用场景

在面向对象编程中,一个类必然会与其他的类发生依赖关系,完全独立的类是没有意义的。一个类同时依赖多个类的情况也相当普遍,既然存在这样的情况,说明,一对多的依赖关系有它的合理性,适当的使用中介者模式可以使原本凌乱的对象关系清晰,但是如果滥用,则可能会带来反的效果。一般来说,只有对于那种同事类之间是网状结构的关系,才会考虑使用中介者模式。可以将网状结构变为星状结构,使同事类之间的关系变的清晰一些。

中介者模式是一种比较常用的模式,也是一种比较容易被滥用的模式。对于大多数的情况,同事类之间的关系不会复杂到混乱不堪的网状结构,因此,大多数情况下,将对象间的依赖关系封装的同事类内部就可以的,没有必要非引入中介者模式。滥用中介者模式,只会让事情变的更复杂。


中介者与门面模式区别

1。门面模式是结构型模式,中介者模式是行为型模式。
2。门面模式是对子系统提供统一的接口,中介者模式是用一个中介对象来封装一系列同事对象的交互行为。
3。门面模式协议是单向,中介者模式协议是双向。
4。门面模式所有的请求处理都委托给子系统完成,而中介者模式则由中心协调同事类和中心本身共同完成业务。

中介者与状态模式

中介者之间的相互影响是通过中介者来完成的,而状态模式是通过各自状态对象来维持的

参考:

http://skhero2012.iteye.com/blog/1489991

《JAVA与模式》之中介者模式(转载)的更多相关文章

  1. Java进阶篇设计模式之十 ---- 访问者模式和中介者模式

    前言 在上一篇中我们学习了行为型模式的解释器模式(Interpreter Pattern)和迭代器模式(Iterator Pattern).本篇则来学习下行为型模式的两个模式,访问者模式(Visito ...

  2. Java设计模式之十 ---- 访问者模式和中介者模式

    前言 2018年已经过去,新的一年工作已经开始,继续总结和学习Java设计模式. 在上一篇中我们学习了行为型模式的解释器模式(Interpreter Pattern)和迭代器模式(Iterator P ...

  3. java设计模式-----17、中介者模式

    概念: Mediator模式也叫中介者模式,是由GoF提出的23种软件设计模式的一种.Mediator模式是行为模式之一,在Mediator模式中,类之间的交互行为被统一放在Mediator的对象中, ...

  4. 重学 Java 设计模式:实战中介者模式「按照Mybaits原理手写ORM框架,给JDBC方式操作数据库增加中介者场景」

    作者:小傅哥 博客:https://bugstack.cn - 原创系列专题文章 沉淀.分享.成长,让自己和他人都能有所收获! 一.前言 同龄人的差距是从什么时候拉开的 同样的幼儿园.同样的小学.一样 ...

  5. 轻松掌握:JavaScript代理模式、中介者模式

    代理模式.中介者模式 代理模式 在面向对象设计中,有一个单一职责原则,指就一个类(对象.函数)而言,应该仅有一个引起它变化的原因.如果一个对象承担了过多的职责,就意味着它将变得巨大,引起它变化的原因就 ...

  6. 【设计模式】 模式PK:门面模式VS中介者模式

    1.概述 门面模式为复杂的子系统提供一个统一的访问界面,它定义的是一个高层接口,该接口使得子系统更加容易使用,避免外部模块深入到子系统内部而产生与子系统内部细节耦合的问题.中介者模式使用一个中介对象来 ...

  7. 《JAVA设计模式》之中介者模式(Mediator)

    在阎宏博士的<JAVA与模式>一书中开头是这样描述调停者(Mediator)模式的: 调停者模式是对象的行为模式.调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显引用.从 ...

  8. Java设计模式系列之中介者模式

    中介者模式(Mediator)的定义 用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 中介者模式(Mediator)的适 ...

  9. Java设计模式学习记录-中介者模式

    前言 中介者模式听名字就能想到也是一种为了解决耦合度的设计模式,其实中介者模式在结构上与观察者.命令模式十分相像:而应用目的又与结构模式“门面模式”有些相似.但区别于命令模式的是大多数中介者角色对于客 ...

  10. 设计模式---接口隔离模式之中介者模式(Mediator)

    一:概念 在Mediator模式中,类之间的交互行为被统一放在Mediator的对象中,对象通过Mediator对象同其他对象交互.Mediator对象起到控制器的作用 二:动机 在软件构建的过程中, ...

随机推荐

  1. MySQL存储引擎与数据类型

    1 数据存储引擎 存储引擎的概念是MySQL的一个特性,它指定了表的类型(诸如表怎样存储与索引数据.是否支持事务.外键等),表在计算机中的存储方式. 1.1 MySql支持的数据存储引擎 查看引擎信息 ...

  2. LintCode: Single Number

    C++ (1)异或操作 3^3=0 (2)for (auto &i : Obejuct) {} class Solution { public: /** * @param A: Array o ...

  3. RESTful Web服务的操作

    1.首先我们说一下Http协议是无状态的 HTTP协议是无状态的,我们看到查到的用到的返回404,500,200,201,202,301.这些不是HTTP协议的状态码. 是HTTP的状态码,就是HTT ...

  4. 数组的翻转(非reverse())

    方法一: var arr = [1,2,3,4]; var arr2 = []; while(arr.length) { var num = arr.pop(); //删除数组最后一个元素并返回被删除 ...

  5. Java并发容器之CopyOnWriteArraySet与ConcurrentSkipListSet

    一:CopyOnWriteArraySet CopyOnWriteArraySet底层其实是通过CopyOnWriteArrayList来实现的,通过组合一个CopyOnWriteArrayList作 ...

  6. Linux 防火墙命令的操作命令CentOS

    service firewalld status; #查看防火墙状态 systemctl start firewalld.service;#开启防火墙 systemctl stop firewalld ...

  7. Web Service 简介

    最近使用ODI的工具箱中的ODIInvokeWebService.因此简单了解下WebService的理论知识. 一.Web Service 简介 Web Service就是可编程的URL,使用标准的 ...

  8. [Android]通过alias映射所有Busybox命令

    # 把Busybox所有的命令通过alias映射出来(若此命令不存在时) # 这么做只是为了平时敲命令行时无须额外的打 busybox (感觉很麻烦的说) for applet in $(busybo ...

  9. codevs 1013 求先序排列

    题目链接:http://codevs.cn/problem/1013/ 题目描述 Description 给出一棵二叉树的中序与后序排列.求出它的先序排列.(约定树结点用不同的大写字母表示,长度< ...

  10. spark rdd Transformation和Action 剖析

    1.看到 这篇总结的这么好, 就悄悄的转过来,供学习 wordcount.toDebugString查看RDD的继承链条 所以广义的讲,对任何函数进行某一项操作都可以认为是一个算子,甚至包括求幂次,开 ...