[关闭]
@w1992wishes 2018-03-13T14:12:07.000000Z 字数 11045 阅读 995

设计模式--中介者模式

设计模式 行为型模式

目录

本文的结构如下：

一、引言

日常开发是离不开电脑的，这需要cpu、内存、显卡、键盘、显示器等零件相互调用，如果直接让这些零件互相调用，它们之间的关系会很复杂：

显然这样造成的后果是难以维护，为了避免这种情况，开发商引入了主板，由主板和各部件进行交互，统一协调，这样每个部件只需要把命令传给主板，由主板决定同哪个部件交互，然后接受主板返回的数据即可，不需要知道其他部件的存在：

在软件开发中，面向对象设计鼓励将行为分布到各个对象中。这种分布可能会导致对象间有许多连接。在最坏的情况下，每一个对象都知道其他所有对象。

将一个系统分割成许多对象通常可以增强可复用性，但是对象间相互连接的激增又会降低其可复用性。大量的相互连接使得一个对象似乎不太可能在没有其他对象的支持下工作—--系统表现为一个不可分割的整体（过度耦合）。而且对系统的行为进行任何较大的改动都十分困难。

这时可以像电脑开发商一样引入“主板”来解决，这就是中介者模式。

二、什么是中介者模式

如果在一个系统中对象之间存在多对多的相互关系（像没有引入主板前电脑各部件，它们被称为“同事类”），这时可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。通过引入中介者来简化对象之间的复杂交互，中介者模式是“迪米特法则”的一个典型应用。

中介者模式定义如下：

中介者模式(Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

中介者模式解决的困境就是多个对象之间的相互引用导致的紧耦合，通过引入一个中介者，原来互相引用的对象就相互解耦了，他们之间现在没有任何关系，只和中介者交互。

说白了中介者模式把对象之间的多对多关系转换成了同中介者类的一对多关系，从而降低耦合。

三、模式的结构

中介者模式UML类图如下：

中介者模式将一个网状的系统结构变成一个以中介者对象为中心的星形结构，在这个星型结构中，使用中介者对象与其他对象的一对多关系来取代原有对象之间的多对多关系。在中介者模式结构图中包含如下几个角色：

中介者模式的核心是中介者类，它承担了两方面的职责：

  1. 中转作用（结构性）：通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。
  2. 协调作用（行为性）：中介者可以更进一步的对同事之间的关系进行封装，同事可以一致的和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

四、典型代码

抽象中介者类典型代码如下：

  1. public abstract class Mediator {
  2.     public abstract void Send(String message, Colleague colleague);
  3. }

具体中介者典型代码如下：

  1. public class ConcreteMediator extends Mediator{
  2.     private ConcreteColleague1 colleague1;
  3.     private ConcreteColleague2 colleague2;
  5.     public void setColleague1(ConcreteColleague1 colleague1) {
  6.         this.colleague1 = colleague1;
  7.     }
  9.     public void setColleague2(ConcreteColleague2 colleague2) {
  10.         this.colleague2 = colleague2;
  11.     }
  13.     public void Send(String message, Colleague colleague) {
  14.         if (colleague == colleague1) {
  15.             colleague2.Notify(message);
  16.         } else if (colleague == colleague2){
  17.             colleague1.Notify(message);
  18.         } else {
  19.             System.out.println("Error!");
  20.         }
  21.     }
  22. }

抽象同事类典型代码：

  1. public abstract class Colleague {
  2.     protected Mediator mediator;
  4.     public Colleague(Mediator mediator) {
  5.         this.mediator = mediator;
  6.     }
  8.     public void Send(String message) {
  9.         mediator.Send(message, this);
  10.     }
  12.     public abstract void Notify(String message);
  13. }

具体同事类典型代码：

  1. public class ConcreteColleague1 extends Colleague{
  2.     public ConcreteColleague1(Mediator mediator) {
  3.         super(mediator);
  4.     }
  6.     public void Notify(String message) {
  7.         System.out.println("同事1得到信息：" + message);
  8.     }
  9. }
  11. public class ConcreteColleague2 extends Colleague{
  12.     public ConcreteColleague2(Mediator mediator) {
  13.         super(mediator);
  14.     }
  16.     public void Notify(String message) {
  17.         System.out.println("同事2得到信息：" + message);
  18.     }
  19. }

客户端测试：

  1. public class MediatorPatternDemo {
  2.     public static void main(String[] args) {
  3.         ConcreteMediator mediator = new ConcreteMediator();
  4.         ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
  5.         ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
  7.         mediator.setColleague1(colleague1);
  8.         mediator.setColleague2(colleague2);
  10.         colleague1.Send("How are you?");
  11.         colleague2.Send("Fine, thank you. And you?");
  12.         colleague1.Send("I'm fine. Thankes.");
  13.     }
  14. }

五、代码示例

5.1、标准中介者模式

假设使用电脑播放视频，把步骤分为如下几步：

  1. 光驱读取光盘内容，把读取到的内容传递给主板。
  2. 主板得到内容，交给cpu处理。
  3. cpu处理完毕，把处理后的数据传递给主板。
  4. 主板把数据传递给显卡，显卡显示视频（忽略了显示器显示这个步骤）。

不使用中介者模式

  1. public class CDDriver{
  2.     private String data;
  3.     private CPU cpu;
  5.     public CDDriver(){
  6.         this.cpu = new CPU();
  7.     }
  9.     public String getData() {
  10.         return data;
  11.     }
  13.     public void readCD(){
  14.         //逗号前是视频数据，逗号后是音频数据
  15.         this.data = "Video Data,Sound Data";
  16.         //然后CPU处理
  17.         cpu.executeData(data);
  18.     }
  19. }
  21. public class CPU{
  22.     private VideoCard videoCard;
  23.     private SoundCard soundCard;
  25.     public CPU() {
  26.         videoCard = new VideoCard();
  27.         soundCard = new SoundCard();
  28.     }
  30.     public void executeData(String data){
  31.         //分解数据，前面是视频数据，后面是音频数据
  32.         String[] ss = data.split(",");
  33.         String videoData = ss[0];
  34.         String soundData = ss[1];
  35.         videoCard.showData(videoData);
  36.         soundCard.soundData(soundData);
  37.     }
  38. }
  40. public class VideoCard{
  41.     public void showData(String data){
  42.         System.out.println("你正在观看的是：" + data);
  43.     }
  44. }
  46. public class SoundCard{
  47.     public void soundData(String data){
  48.         System.out.println("你听到的声音是：" + data);
  49.     }
  50. }

这里设计的关联其实还算简单，并没有很复杂，但仍然会发现有以下问题：

使用中介者模式

抽象中介者：

  1. public interface Mediator {
  2.     void changed(Colleague colleague);
  3. }

具体中介者主板类：

  1. public class MainBoard implements Mediator {
  2.     private CDDriver cdDriver;
  3.     private CPU cpu;
  4.     private VideoCard videoCard;
  5.     private SoundCard soundCard;
  7.     public void changed(Colleague colleague) {
  8.         if(colleague == cdDriver){
  9.             //表示光驱读取了数据
  10.             this.operateCDDriverReadData((CDDriver)colleague);
  11.         }else if(colleague == cpu){
  12.             //表示CPU处理完数据
  13.             this.operateCPU((CPU)colleague);
  14.         }
  15.     }
  17.     public void setCdDriver(CDDriver cdDriver) {
  18.         this.cdDriver = cdDriver;
  19.     }
  21.     public void setCpu(CPU cpu) {
  22.         this.cpu = cpu;
  23.     }
  25.     public void setVideoCard(VideoCard videoCard) {
  26.         this.videoCard = videoCard;
  27.     }
  29.     public void setSoundCard(SoundCard soundCard) {
  30.         this.soundCard = soundCard;
  31.     }
  33.     public void operateCDDriverReadData(CDDriver cd){
  34.         String data = cd.getData();
  35.         this.cpu.executeData(data);
  36.     }
  38.     public void operateCPU(CPU cpu){
  39.         String videoData = cpu.getVideoData();
  40.         String soundData = cpu.getSoundData();
  41.         this.videoCard.showData(videoData);
  42.         this.soundCard.soundData(soundData);
  43.     }
  44. }

抽象同事类：

  1. public abstract class Colleague {
  2.     private final Mediator mediator;
  4.     public Colleague(Mediator mediator){
  5.         this.mediator = mediator;
  6.     }
  8.     public Mediator getMediator(){
  9.         return mediator;
  10.     }
  11. }

具体同事类：

  1. public class CDDriver extends Colleague {
  2.     private String data;
  4.     public CDDriver(Mediator mediator) {
  5.         super(mediator);
  6.     }
  8.     public String getData() {
  9.         return data;
  10.     }
  12.     public void readCD(){
  13.         //逗号前是视频数据，逗号后是音频数据
  14.         this.data = "Video Data,Sound Data";
  15.         //通知主板，自己的状态发生了变化
  16.         this.getMediator().changed(this);
  17.     }
  18. }
  20. public class CPU extends Colleague {
  21.     private String videoData;
  22.     private String soundData;
  24.     public CPU(Mediator mediator) {
  25.         super(mediator);
  26.     }
  28.     public String getVideoData() {
  29.         return videoData;
  30.     }
  32.     public String getSoundData() {
  33.         return soundData;
  34.     }
  36.     public void executeData(String data){
  37.         //分解数据，前面是视频数据，后面是音频数据
  38.         String[] ss = data.split(",");
  39.         this.videoData = ss[0];
  40.         this.soundData = ss[1];
  41.         //通知主板，CPU的工作完成
  42.         this.getMediator().changed(this);
  43.     }
  44. }
  46. public class VideoCard extends Colleague{
  47.     public VideoCard(Mediator mediator) {
  48.         super(mediator);
  49.     }
  51.     public void showData(String data){
  52.         System.out.println("你正在观看的是：" + data);
  53.     }
  54. }
  56. public class SoundCard extends Colleague {
  57.     public SoundCard(Mediator mediator) {
  58.         super(mediator);
  59.     }
  61.     public void soundData(String data){
  62.         System.out.println("你听到的声音是：" + data);
  63.     }
  64. }

客户端测试：

  1. public class MediatorPatternDemo {
  2.     public static void main(String[] args) {
  3.         MainBoard mediator = new MainBoard();
  4.         CDDriver cd = new CDDriver(mediator);
  5.         CPU cpu = new CPU(mediator);
  6.         VideoCard vc = new VideoCard(mediator);
  7.         SoundCard sc = new SoundCard(mediator);
  9.         mediator.setCdDriver(cd);
  10.         mediator.setCpu(cpu);
  11.         mediator.setVideoCard(vc);
  12.         mediator.setSoundCard(sc);
  14.         cd.readCD();
  15.     }
  16. }

引入中介者类后，再来看就会发现组件之间不再相互关联，系统之间耦合度降低，更易复用，扩展和维护，当然会发现系统相关变得复杂。

5.2、更广义的中介者模式

我们知道现实开发中，很多时候不会完全符合标准中介者模式，这时可以实际情况做一些变化，比如：

现假设有有小说类和类别类，为此制定了一个书单，书单上有平时追更的小说，当小说完结了，也就追更完毕，就把小说从书单删除；还有可以将冷门类别的小说从书单删除......

这样实现：

  1. public class Novel {
  2.     private String novelId;
  3.     private String novelName;
  4.     private boolean finsh;
  6.     public Novel(String novelId, String novelName){
  7.         this.novelId = novelId;
  8.         this.novelName = novelName;
  9.     }
  11.     public String getNovelId() {
  12.         return novelId;
  13.     }
  15.     public String getNovelName() {
  16.         return novelName;
  17.     }
  19.     public void setNovelId(String novelId) {
  20.         this.novelId = novelId;
  21.     }
  23.     public void setNovelName(String novelName) {
  24.         this.novelName = novelName;
  25.     }
  27.     public boolean isFinsh() {
  28.         return finsh;
  29.     }
  31.     public void setFinsh(boolean finsh) {
  32.         //如果完结了，就从书单删除
  33.         if (finsh){
  34.             NovelTypeMediator mediator = NovelTypeMediator.getInstance();
  35.             mediator.removeNovel(novelId);
  36.         }
  37.         this.finsh = finsh;
  38.     }
  39. }
  41. public class Type {
  42.     private String typeId;
  43.     private String typeName;
  44.     private boolean unpopular;
  46.     public Type(String typeId, String typeName) {
  47.         this.typeId = typeId;
  48.         this.typeName = typeName;
  49.     }
  51.     public void setTypeId(String typeId) {
  52.         this.typeId = typeId;
  53.     }
  55.     public void setTypeName(String typeName) {
  56.         this.typeName = typeName;
  57.     }
  59.     public String getTypeId() {
  60.         return typeId;
  61.     }
  63.     public String getTypeName() {
  64.         return typeName;
  65.     }
  67.     public boolean isUnpopular() {
  68.         return unpopular;
  69.     }
  71.     public void setUnpopular(boolean unpopular) {
  72.         if (unpopular){
  73.             NovelTypeMediator mediator = NovelTypeMediator.getInstance();
  74.             mediator.removeType(typeId);
  75.         }
  76.         this.unpopular = unpopular;
  77.     }
  78. }
  80. public class NovelTypeRelation {
  81.     private String id;
  82.     private String novelId;
  83.     private String typeId;
  85.     public NovelTypeRelation(String id, String novelId, String typeId) {
  86.         this.id = id;
  87.         this.novelId = novelId;
  88.         this.typeId = typeId;
  89.     }
  91.     public String getId() {
  92.         return id;
  93.     }
  95.     public String getNovelId() {
  96.         return novelId;
  97.     }
  99.     public String getTypeId() {
  100.         return typeId;
  101.     }
  103.     public void setId(String id) {
  104.         this.id = id;
  105.     }
  107.     public void setNovelId(String novelId) {
  108.         this.novelId = novelId;
  109.     }
  111.     public void setTypeId(String typeId) {
  112.         this.typeId = typeId;
  113.     }
  114. }
  116. public class NovelTypeMediator {
  117.     private static NovelTypeMediator instance = new NovelTypeMediator();
  119.     //书单
  120.     private List<NovelTypeRelation> novelList = new ArrayList<NovelTypeRelation>();
  122.     public static NovelTypeMediator getInstance(){
  123.         return instance;
  124.     }
  126.     private NovelTypeMediator(){
  127.         initData();
  128.     }
  130.     private void initData() {
  131.         NovelTypeRelation n1 = new NovelTypeRelation("1", "1n", "1t");
  132.         NovelTypeRelation n2 = new NovelTypeRelation("2", "2n", "1t");
  133.         NovelTypeRelation n3 = new NovelTypeRelation("3", "3n", "2t");
  134.         NovelTypeRelation n4 = new NovelTypeRelation("4", "4n", "2t");
  136.         novelList.add(n1);
  137.         novelList.add(n2);
  138.         novelList.add(n3);
  139.         novelList.add(n4);
  140.     }
  142.     /**
  143.      * 展示书单
  144.      */
  145.     public void showNovelList(){
  146.         for (NovelTypeRelation relation : novelList){
  147.             System.out.println("小说编号是：" + relation.getNovelId() + "， 类型编号是：" + relation.getTypeId());
  148.         }
  149.     }
  151.     /**
  152.      * 删除小说
  153.      * @param novelId
  154.      */
  155.     public void removeNovel(String novelId){
  156.         for (Iterator<NovelTypeRelation> itr = novelList.iterator(); itr.hasNext();){
  157.             NovelTypeRelation relation = itr.next();
  158.             if (relation.getNovelId().equals(novelId)){
  159.                 itr.remove();
  160.             }
  161.         }
  162.     }
  164.     /**
  165.      * 删除类型
  166.      * @param typeId
  167.      */
  168.     public void removeType(String typeId){
  169.         for (Iterator<NovelTypeRelation> itr = novelList.iterator(); itr.hasNext();){
  170.             NovelTypeRelation relation = itr.next();
  171.             if (relation.getTypeId().equals(typeId)){
  172.                 itr.remove();
  173.             }
  174.         }
  175.     }
  176. }

测试类：

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         NovelTypeMediator mediator = NovelTypeMediator.getInstance();
  5.         //展示书单
  6.         mediator.showNovelList();
  8.         //完结
  9.         Novel novel = new Novel("1n", "诛仙");
  10.         novel.setFinsh(true);
  11.         System.out.println("----------------一本小说完结后的书单------------------");
  12.         mediator.showNovelList();
  14.         //撤销分类2t
  15.         Type type = new Type("2t", "奇异");
  16.         type.setUnpopular(true);
  17.         System.out.println("----------------删除一个分类后------------------");
  18.         mediator.showNovelList();
  19.     }
  20. }

这里的Novel和Type都抽象父类，但依旧都可以当作同事类，NovelTypeMediator则为单例中介者。

六、优点和缺点

6.1、优点

中介者模式的主要优点如下：

6.2、缺点

中介者模式的主要缺点如下：

七、适用环境

在以下情况下可以使用中介者模式：

八、模式应用

MVC架构中控制器Controller作为一种中介者，它负责控制视图对象View和模型对象Model之间的交互。如在Struts中，Action就可以作为JSP页面与业务对象之间的中介者。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注