欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

详解Java设计模式编程中的中介者模式

程序员文章站 2024-03-08 16:20:24
定义:用一个中介者对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使耦合松散,而且可以独立地改变它们之间的交互。 类型:行为类模式 类图:...

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

详解Java设计模式编程中的中介者模式

中介者模式的结构
       中介者模式又称为调停者模式,从类图中看,共分为3部分:
 抽象中介者:定义好同事类对象到中介者对象的接口,用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法,并由子类去实现。
中介者实现类:从抽象中介者继承而来,实现抽象中介者中定义的事件方法。从一个同事类接收消息,然后通过消息影响其他同时类。
同事类:如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对象称为同事类。在类图中,同事类只有一个,这其实是现实的省略,在实际应用中,同事类一般由多个组成,他们之间相互影响,相互依赖。同事类越多,关系越复杂。并且,同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中,同事类之间必须通过中介者才能进行消息传递。
为什么要使用中介者模式
       一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下图中,有六个同事类对象,假如对象1发生变化,那么将会有4个对象受到影响。如果对象2发生变化,那么将会有5个对象受到影响。也就是说,同事类之间直接关联的设计是不好的。

详解Java设计模式编程中的中介者模式详解Java设计模式编程中的中介者模式

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

详解Java设计模式编程中的中介者模式


下面给出具体的代码例子,对比通用类图增加了abstractcolleague抽象同事类和abstractmediator抽象中介者,另外就是两个具体同事类和一个具体中介者,代码中有较多注释,相应类图也不给出了,应该不难理解的:
 
同事类族:

//抽象同事类 
abstract class abstractcolleague { 
  protected abstractmediator mediator; 
   
  /**既然有中介者,那么每个具体同事必然要与中介者有联系, 
   * 否则就没必要存在于 这个系统当中,这里的构造函数相当 
   * 于向该系统中注册一个中介者,以取得联系 
   */ 
  public abstractcolleague(abstractmediator mediator) { 
    this.mediator = mediator; 
  } 
   
  // 在抽象同事类中添加用于与中介者取得联系(即注册)的方法 
  public void setmediator(abstractmediator mediator) { 
    this.mediator = mediator; 
  } 
} 
 
//具体同事a 
class colleaguea extends abstractcolleague { 
   
  //每个具体同事都通过父类构造函数与中介者取得联系 
  public colleaguea(abstractmediator mediator) { 
    super(mediator); 
  } 
   
  //每个具体同事必然有自己分内的事,没必要与外界相关联 
  public void self() { 
    system.out.println("同事a --> 做好自己分内的事情 ..."); 
  } 
   
  //每个具体同事总有需要与外界交互的操作,通过中介者来处理这些逻辑并安排工作 
  public void out() { 
    system.out.println("同事a --> 请求同事b做好分内工作 ..."); 
    super.mediator.execute("colleagueb", "self"); 
  } 
} 
 
//具体同事b 
class colleagueb extends abstractcolleague { 
   
  public colleagueb(abstractmediator mediator) { 
    super(mediator); 
  } 
   
  public void self() { 
    system.out.println("同事b --> 做好自己分内的事情 ..."); 
  } 
   
  public void out() { 
    system.out.println("同事b --> 请求同事a做好分内工作 ..."); 
    super.mediator.execute("colleaguea", "self"); 
  } 
} 

中介者类族:

//抽象中介者 
abstract class abstractmediator { 
   
  //中介者肯定需要保持有若干同事的联系方式 
  protected hashtable<string, abstractcolleague> colleagues = new hashtable<string, abstractcolleague>(); 
   
  //中介者可以动态地与某个同事建立联系 
  public void addcolleague(string name, abstractcolleague c) { 
    this.colleagues.put(name, c); 
  }   
   
  //中介者也可以动态地撤销与某个同事的联系 
  public void deletecolleague(string name) { 
    this.colleagues.remove(name); 
  } 
   
  //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作 
  public abstract void execute(string name, string method);  
} 
 
//具体中介者 
class mediator extends abstractmediator{ 
   
  //中介者最重要的功能,来回奔波与各个同事之间 
  public void execute(string name, string method) { 
     
    if("self".equals(method)){ //各自做好分内事 
      if("colleaguea".equals(name)) { 
        colleaguea colleague = (colleaguea)super.colleagues.get("colleaguea"); 
        colleague.self(); 
      }else { 
        colleagueb colleague = (colleagueb)super.colleagues.get("colleagueb"); 
        colleague.self(); 
      } 
    }else { //与其他同事合作 
      if("colleaguea".equals(name)) { 
        colleaguea colleague = (colleaguea)super.colleagues.get("colleaguea"); 
        colleague.out(); 
      }else { 
        colleagueb colleague = (colleagueb)super.colleagues.get("colleagueb"); 
        colleague.out(); 
      } 
    } 
  } 
} 

测试类:

//测试类 
public class client { 
  public static void main(string[] args) { 
     
    //创建一个中介者 
    abstractmediator mediator = new mediator(); 
     
    //创建两个同事 
    colleaguea colleaguea = new colleaguea(mediator); 
    colleagueb colleagueb = new colleagueb(mediator); 
     
    //中介者分别与每个同事建立联系 
    mediator.addcolleague("colleaguea", colleaguea); 
    mediator.addcolleague("colleagueb", colleagueb); 
     
    //同事们开始工作 
    colleaguea.self(); 
    colleaguea.out(); 
    system.out.println("======================合作愉快,任务完成!\n"); 
     
    colleagueb.self(); 
    colleagueb.out(); 
    system.out.println("======================合作愉快,任务完成!"); 
  } 
} 

测试结果: 

同事a --> 做好自己分内的事情 ... 
同事a --> 请求同事b做好分内工作 ... 
同事b --> 做好自己分内的事情 ... 
======================合作愉快,任务完成! 
 
同事b --> 做好自己分内的事情 ... 
同事b --> 请求同事a做好分内工作 ... 
同事a --> 做好自己分内的事情 ... 
======================合作愉快,任务完成! 

 
虽然以上代码中只有两个具体同事类,并且测试类中也只是创建了两个同事,但是这些我们都可以根据中介者模式的宗旨进行适当地扩展,即增加具体同事类,然后中介者就得担负更加重的任务了。为啥?我们看到上面具体中介者类mediator中的execute()方法中现在就有一堆冗长的判断代码了。虽然可以把它分解并增加到mediator类中的其它private方法中,但是具体的业务逻辑是少不了的。
 
所以,在解耦同事类之间的联系的同时,中介者自身也不免任务过重,因为几乎所有的业务逻辑都交代到中介者身上了,可谓是“万众期待”的一个角色了。这就是中介者模式的不足之处了 。
此外,上面这个代码例子是相当理想的了,有时候我们根本抽取不了“同事”之间的共性来形成一个abstractcolleague抽象同事类,这也大大增加了中介者模式的使用难度。  
修改:
由于上面代码实现中存在 benjielin 前辈提出的“双向关联暴露在app中”的不足之处,根据给出的改进方法2,修改上面代码,如下:
 
修改后的同事类族:
 

//抽象同事类 
abstract class abstractcolleague { 
  protected abstractmediator mediator;   
   
  //舍去在构造函数中建立起与中介者的联系 
// public abstractcolleague(abstractmediator mediator) { 
//   this.mediator = mediator; 
// } 
   
  // 在抽象同事类中添加用于与中介者取得联系(即注册)的方法 
  public void setmediator(abstractmediator mediator) { 
    this.mediator = mediator; 
  } 
} 
 
//具体同事a 
class colleaguea extends abstractcolleague { 
   
  //舍去在构造函数中建立起与中介者的联系 
// public colleaguea(abstractmediator mediator) { 
//   super(mediator); 
// } 
   
  //每个具体同事必然有自己分内的事,没必要与外界相关联 
  public void self() { 
    system.out.println("同事a --> 做好自己分内的事情 ..."); 
  } 
   
  //每个具体同事总有需要与外界交互的操作,通过中介者来处理这些逻辑并安排工作 
  public void out() { 
    system.out.println("同事a --> 请求同事b做好分内工作 ..."); 
    super.mediator.execute("colleagueb", "self"); 
  } 
} 
 
//具体同事b 
class colleagueb extends abstractcolleague { 
  //舍去在构造函数中建立起与中介者的联系 
// public colleagueb(abstractmediator mediator) { 
//   super(mediator); 
// } 
   
  public void self() { 
    system.out.println("同事b --> 做好自己分内的事情 ..."); 
  } 
   
  public void out() { 
    system.out.println("同事b --> 请求同事a做好分内工作 ..."); 
    super.mediator.execute("colleaguea", "self"); 
  } 
} 

 
修改后的中介者:

 //抽象中介者 
abstract class abstractmediator { 
   
  //中介者肯定需要保持有若干同事的联系方式 
  protected hashtable<string, abstractcolleague> colleagues = new hashtable<string, abstractcolleague>(); 
   
  //中介者可以动态地与某个同事建立联系 
  public void addcolleague(string name, abstractcolleague c) { 
     
    // 在中介者这里帮助具体同事建立起于中介者的联系 
    c.setmediator(this); 
    this.colleagues.put(name, c); 
  }   
   
  //中介者也可以动态地撤销与某个同事的联系 
  public void deletecolleague(string name) { 
    this.colleagues.remove(name); 
  } 
   
  //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作 
  public abstract void execute(string name, string method);  
} 
//测试类 
public class client { 
  public static void main(string[] args) { 
     
    //创建一个中介者 
    abstractmediator mediator = new mediator(); 
     
    //不用构造函数为具体同事注册中介者来取得联系了 
//   colleaguea colleaguea = new colleaguea(mediator); 
//   colleagueb colleagueb = new colleagueb(mediator); 
     
    colleaguea colleaguea = new colleaguea(); 
    colleagueb colleagueb = new colleagueb(); 
     
    //中介者分别与每个同事建立联系 
    mediator.addcolleague("colleaguea", colleaguea); 
    mediator.addcolleague("colleagueb", colleagueb); 
     
    //同事们开始工作 
    colleaguea.self(); 
    colleaguea.out(); 
    system.out.println("======================合作愉快,任务完成!\n"); 
     
    colleagueb.self(); 
    colleagueb.out(); 
    system.out.println("======================合作愉快,任务完成!"); 
  } 
} 

  测试之后的结果与修改前一样。

上一篇: 我的第一个mybatis程序

下一篇: