外观模式与中介者模式的异同点(设计模式系列中介者模式)(1)

作者公众号:一角钱技术(org_yijiaoqian)

前言

23种设计模式快速记忆的请看上面第一篇,本篇和大家一起来学习中介者模式相关内容。

外观模式与中介者模式的异同点(设计模式系列中介者模式)(2)

模式定义

定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。中介者模式又叫调停模式,它是迪米特法则的典型应用。

迪米特法则(Law of Demeter,LoD)又叫作最少知识原则(Least Knowledge Principle,LKP),产生于 1987 年美国东北大学(Northeastern University)的一个名为迪米特(Demeter)的研究项目,由伊恩·荷兰(Ian Holland)提出,被 UML 创始者之一的布奇(Booch)普及,后来又因为在经典著作《程序员修炼之道》(The Pragmatic Programmer)提及而广为人知。

迪米特法则的定义是:只与你的直接朋友交谈,不跟“陌生人”说话(Talk only to your immediate friends and not to strangers)。其含义是:如果两个软件实体无须直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发该调用。其目的是降低类之间的耦合度,提高模块的相对独立性。

迪米特法则中的“朋友”是指:当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等,这些对象同当前对象存在关联、聚合或组合关系,可以直接访问这些对象的方法。

外观模式与中介者模式的异同点(设计模式系列中介者模式)(3)

模板实现如下

packagecom.niuh.designpattern.mediator.v1; importjava.util.ArrayList; importjava.util.List; /** *<p> *中介者模式 *</p> */ publicclassMediatorPattern{ publicstaticvoidmain(String[]args){ Mediatormd=newConcreteMediator(); Colleaguec1,c2; c1=newConcreteColleague1(); c2=newConcreteColleague2(); md.register(c1); md.register(c2); c1.send(); System.out.println("=============="); c2.send(); } } //抽象中介者 abstractclassMediator{ publicabstractvoidregister(Colleaguecolleague); publicabstractvoidrelay(Colleaguecl);//转发 } //具体中介者 classConcreteMediatorextendsMediator{ privateList<Colleague>colleagues=newArrayList<Colleague>(); publicvoidregister(Colleaguecolleague){ if(!colleagues.contains(colleague)){ colleagues.add(colleague); colleague.setMedium(this); } } publicvoidrelay(Colleaguecl){ for(Colleagueob:colleagues){ if(!ob.equals(cl)){ ((Colleague)ob).receive(); } } } } //抽象同事类 abstractclassColleague{ protectedMediatormediator; publicvoidsetMedium(Mediatormediator){ this.mediator=mediator; } publicabstractvoidreceive(); publicabstractvoidsend(); } //具体同事类 classConcreteColleague1extendsColleague{ publicvoidreceive(){ System.out.println("具体同事类1收到请求。"); } publicvoidsend(){ System.out.println("具体同事类1发出请求。"); mediator.relay(this);//请中介者转发 } } //具体同事类 classConcreteColleague2extendsColleague{ publicvoidreceive(){ System.out.println("具体同事类2收到请求。"); } publicvoidsend(){ System.out.println("具体同事类2发出请求。"); mediator.relay(this);//请中介者转发 } }

结果实现如下

具体同事类1发出请求。 具体同事类2收到请求。 ============== 具体同事类2发出请求。 具体同事类1收到请求。

解决的问题

对象与对象之间存在大量的关联关系,这样势必会导致系统的结构变得很复杂,同时若一个对象发生改变,我们也需要跟踪与之相关联的对象,同时做出相应的处理。

模式组成

中介者模式实现的关键是找出“中介者”。

外观模式与中介者模式的异同点(设计模式系列中介者模式)(4)

实例说明实例概况

用中介者模式编写一个“北京房地产交流平台”程序。

分析:北京房地产交流平台是“房地产中介公司”提供给“卖方客户”与“买方客户”进行信息交流的平台,比较适合用中介者模式来实现。

外观模式与中介者模式的异同点(设计模式系列中介者模式)(5)

使用步骤

步骤1:定义一个中介公司(Medium)接口,它是抽象中介者,它包含了客户注册方法 register(Customer member) 和信息转发方法 relay(String from,String ad);

interfaceMedium{ //客户注册 voidregister(Customermember); //转发 voidrelay(Stringfrom,Stringad); }

步骤2:定义一个北京房地产中介(EstateMedium)公司,它是具体中介者类,它包含了保存客户信息的 List 对象,并实现了中介公司中的抽象方法。

//具体中介者:房地产中介 classEstateMediumimplementsMedium{ privateList<Customer>members=newArrayList<Customer>(); publicvoidregister(Customermember){ if(!members.contains(member)){ members.add(member); member.setMedium(this); } } publicvoidrelay(Stringfrom,Stringad){ for(Customerob:members){ Stringname=ob.getName(); if(!name.equals(from)){ ((Customer)ob).receive(from,ad); } } } }

步骤3:定义一个客户(Qistomer)类,它是抽象同事类,其中包含了中介者的对象,和发送信息的 send(String ad) 方法与接收信息的 receive(String from,Stringad) 方法的接口,由于本程序是窗体程序,所以本类继承 JPmme 类,并实现动作事件的处理方法 actionPerformed(ActionEvent e)。

//抽象同事类:客户 abstractclassCustomerextendsJFrameimplementsActionListener{ privatestaticfinallongserialVersionUID=-7219939540794786080L; protectedMediummedium; protectedStringname; JTextFieldSentText; JTextAreaReceiveArea; publicCustomer(Stringname){ super(name); this.name=name; } voidClientWindow(intx,inty){ Containercp; JScrollPanesp; JPanelp1,p2; cp=this.getContentPane(); SentText=newJTextField(18); ReceiveArea=newJTextArea(10,18); ReceiveArea.setEditable(false); p1=newJPanel(); p1.setBorder(BorderFactory.createTitledBorder("接收内容:")); p1.add(ReceiveArea); sp=newJScrollPane(p1); cp.add(sp,BorderLayout.NORTH); p2=newJPanel(); p2.setBorder(BorderFactory.createTitledBorder("发送内容:")); p2.add(SentText); cp.add(p2,BorderLayout.SOUTH); SentText.addActionListener(this); this.setLocation(x,y); this.setSize(250,330); this.setResizable(false);//窗口大小不可调整 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true); } publicvoidactionPerformed(ActionEvente){ StringtempInfo=SentText.getText().trim(); SentText.setText(""); this.send(tempInfo); } publicStringgetName(){ returnname; } publicvoidsetMedium(Mediummedium){ this.medium=medium; } publicabstractvoidsend(Stringad); publicabstractvoidreceive(Stringfrom,Stringad); }

步骤4:定义卖方(Seller)类和买方(Buyer)类,它们是具体同事类,是客户(Customer)类的子类,它们实现了父类中的抽象方法,通过中介者类进行信息交流。

//具体同事类:卖方 classSellerextendsCustomer{ privatestaticfinallongserialVersionUID=-1443076716629516027L; publicSeller(Stringname){ super(name); ClientWindow(50,100); } publicvoidsend(Stringad){ ReceiveArea.append("我(卖方)说:" ad "\n"); //使滚动条滚动到最底端 ReceiveArea.setCaretPosition(ReceiveArea.getText().length()); medium.relay(name,ad); } publicvoidreceive(Stringfrom,Stringad){ ReceiveArea.append(from "说:" ad "\n"); //使滚动条滚动到最底端 ReceiveArea.setCaretPosition(ReceiveArea.getText().length()); } } //具体同事类:买方 classBuyerextendsCustomer{ privatestaticfinallongserialVersionUID=-474879276076308825L; publicBuyer(Stringname){ super(name); ClientWindow(350,100); } publicvoidsend(Stringad){ ReceiveArea.append("我(买方)说:" ad "\n"); //使滚动条滚动到最底端 ReceiveArea.setCaretPosition(ReceiveArea.getText().length()); medium.relay(name,ad); } publicvoidreceive(Stringfrom,Stringad){ ReceiveArea.append(from "说:" ad "\n"); //使滚动条滚动到最底端 ReceiveArea.setCaretPosition(ReceiveArea.getText().length()); } }

输出结果

外观模式与中介者模式的异同点(设计模式系列中介者模式)(6)

优点
  1. 降低了对象之间的耦合性,使得对象易于独立地被复用。
  2. 将对象间的一对多关联转变为一对一的关联,提高系统的灵活性,使得系统易于维护和扩展。
缺点

当同事类太多时,中介者的职责将很大,它会变得复杂而庞大,以至于系统难以维护。

应用场景模式的扩展

在实际开发中,通常采用以下两种方法来简化中介者模式,使开发变得更简单。

  1. 不定义中介者接口,把具体中介者对象实现成为单例。
  2. 同事对象不持有中介者,而是在需要的时候直接获取中介者对象并调用。

外观模式与中介者模式的异同点(设计模式系列中介者模式)(7)

程序代码如下

packagecom.niuh.designpattern.mediator.v3; importjava.util.ArrayList; importjava.util.List; /** *<p> *简化中介者模式 *</p> */ publicclassSimpleMediatorPattern{ publicstaticvoidmain(String[]args){ SimpleColleaguec1,c2; c1=newSimpleConcreteColleague1(); c2=newSimpleConcreteColleague2(); c1.send(); System.out.println("=============="); c2.send(); } } //简单单例中介者 classSimpleMediator{ privatestaticSimpleMediatorsmd=newSimpleMediator(); privateList<SimpleColleague>colleagues=newArrayList<SimpleColleague>(); privateSimpleMediator(){ } publicstaticSimpleMediatorgetMedium(){ return(smd); } publicvoidregister(SimpleColleaguecolleague){ if(!colleagues.contains(colleague)){ colleagues.add(colleague); } } publicvoidrelay(SimpleColleaguescl){ for(SimpleColleagueob:colleagues){ if(!ob.equals(scl)){ ((SimpleColleague)ob).receive(); } } } } //抽象同事类 interfaceSimpleColleague{ voidreceive(); voidsend(); } //具体同事类 classSimpleConcreteColleague1implementsSimpleColleague{ SimpleConcreteColleague1(){ SimpleMediatorsmd=SimpleMediator.getMedium(); smd.register(this); } publicvoidreceive(){ System.out.println("具体同事类1:收到请求。"); } publicvoidsend(){ SimpleMediatorsmd=SimpleMediator.getMedium(); System.out.println("具体同事类1:发出请求..."); smd.relay(this);//请中介者转发 } } //具体同事类 classSimpleConcreteColleague2implementsSimpleColleague{ SimpleConcreteColleague2(){ SimpleMediatorsmd=SimpleMediator.getMedium(); smd.register(this); } publicvoidreceive(){ System.out.println("具体同事类2:收到请求。"); } publicvoidsend(){ SimpleMediatorsmd=SimpleMediator.getMedium(); System.out.println("具体同事类2:发出请求..."); smd.relay(this);//请中介者转发 } }

输出结果如下

具体同事类1:发出请求... 具体同事类2:收到请求。 ============== 具体同事类2:发出请求... 具体同事类1:收到请求。

源码中的应用

java.util.Timer java.util.concurrent.Executer#execute() java.util.concurrent.ExecuterService#submit() java.lang.reflect.Method#invoke()

PS:以上代码提交在 Github

https://github.com/Niuh-Study/niuh-designpatterns.git

文章持续更新,可以公众号搜一搜「 一角钱技术 」第一时间阅读, 本文 GitHub org_hejianhui/JavaStudy 已经收录,欢迎 Star。

,