Android编程设计模式之中介者模式详解

本文实例讲述了Android编程设计模式之中介者模式。分享给大家供大家参考，具体如下：

一、介绍

中介者模式（Mediator Pattern）也称为调解者模式或调停者模式，Mediator本身就有调停者和调解者的意思。

在日常生活中调停者或调解者这个角色我们见得比较多的是“和事老”，也就是说调解两个有争端的人的角色，举个不恰当的例子，比如爸妈吵架，孩子或者双方父母则会出面劝架或阻止争吵，这里孩子或双方父母则是充当的是调解者的模式。

而对于中介呢？大家平时听得最多的莫过于房产中介了，在房地产飞速发展的今天，各种房产中介公司如雨后春笋般冒出来，房产中介承担的责任很简单，就是在买房者与卖房者之间建立一座桥梁沟通两者，比如小民现在手里有套房子需要出售，于是他找房产中介并告诉房产中介房子的期望售价和房子的相关信息，然后房产中介则将这些信息收集汇总有时还会美化一番，然后把广告挂在橱窗里等待买房者，如果有人有意向购买这套房子，比如这里以小辉为例，房产中介就会告诉小辉关于这套房产的相关信息，如房龄、售价等，有时还会带小辉去房子里实际参观一番，最终小辉将自己的意愿告诉房产中介，再由房产中介去与小民进行沟通。也就是说在整个房产协商的过程中，小民和小辉买卖双方是很少直接接触的，大多数情况下都是通过房产中介来传达信息，可能只有在最终进行房产交接时小民和小辉才会正式见面。

这就是我们现实生活中常见的调解者与中介者，但是，这里我们要说的中介者模式比起上述的两个例子来要复杂的多，上面我们所述的例子中，中介者或调解者所要协调的也就两类对象，而我们的中介者模式中需要协调的是多类对象。

这里还是举一个小例子来说明，本书的阅读者大多都是IT从业者，说得更准确些都是做APP的，一般来说，一个做APP的公司可以分为几大模块：运维、产品、开发、设计还有测试，每当一个新APP开始制作或者发布新版本需要制作之前，公司会开一个研讨会，运维负责市场了解用户使用倾向，研发的会说用户反映界面不好看要求修改界面……这样大家你一句我一句的讨论一半天也没有啥实质性结果，主要原因在于大家都站在自己的立场考虑问题，这样的团队研讨会即使再开下去也没什么意义，这时候如果有一个人不属于运维、产品、开发、设计任一方的人站出来说，大家把各自的意见都跟我说，由我来权衡并作出最终的决定，不管决定如何你们都要照做。因为这个人不代表任何一方，于是大家都全票表示肯定，这么一来一个方案很快就定下来，而这个作出最终决定的人我们就称之为中介者，这里的中介者与我们的中介者模式一样面对的是多类对象，这里其实大家可以看到中介者模式的一些特性，每一个中介者都会知道所有的同事，比如上面我们所说的运维、产品、开发、设计还有测试，但是这些同事呢可以互不相识，而中介者不属于同事的任何一方，也不偏袒任何一方，这么一说相信大家对中介者模式会有一个非常清晰的了解。

二、定义

中介者模式包装了一系列对象互相作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

三、使用场景

当对象之间的交互操作很多且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的行为时，同时涉及修改很多其他对象的行为，可采用中介者模式，来解决紧耦合问题。该模式将对象之间的多对多关系变成一对多关系，中介者对象将系统从网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

四、中介者模式的UML类图

UML类图：

角色介绍：

Mediator：抽象的中介者角色，定义了同事对象到中介者的接口。

ConcreteMediator：具体的中介者角色，从具体的同事对象接收消息，同时向具体的同事对象发出命令。

Colleague：抽象同事类角色，定义了中介者对象的接口，只知道中介而不知道其他同事对象。

ConcreteColleagueA，ConcreteColleagueB：具体的同事类角色，每个具体同事类都知道本身在小范围内的行为，而不知道他在大范围中的行为。

模板代码：

抽象的中介者：

public interface Mediator {
  void change();
}

具体的中介者：

public class ConcreteMediator implements Mediator {
  public ConcreteColleagueA concreteColleagueA;
  public ConcreteColleagueB concreteColleagueB;
  public void setConcreteColleagueA(ConcreteColleagueA concreteColleagueA) {
    this.concreteColleagueA = concreteColleagueA;
  }
  public void setConcreteColleagueB(ConcreteColleagueB concreteColleagueB) {
    this.concreteColleagueB = concreteColleagueB;
  }
  @Override
  public void change() {
    concreteColleagueA.action();
    concreteColleagueB.action();
  }
}

抽象的同事：

public abstract class Colleague {
  public Mediator mediator;
  public Colleague(Mediator mediator) {
    this.mediator = mediator;
  }
  public abstract void action();
}

具体的同事A：

public class ConcreteColleagueA extends Colleague {
  public ConcreteColleagueA(Mediator mediator) {
    super(mediator);
  }
  @Override
  public void action() {
    System.out.println("交给中介做A的事情");
  }
}

具体的同事B：

public class ConcreteColleagueB extends Colleague {
  public ConcreteColleagueB(Mediator mediator) {
    super(mediator);
  }
  @Override
  public void action() {
    System.out.println("交给中介做B的事情");
  }
}

五、简单示例

在电脑中，主机部分主要分为：CPU、内存、显卡、IO设备，而将它们整合起来的就是主板，这里主板就是一个中介者。以此为例。

抽象中介者：

public abstract class Mediator {
  /**
   * 同事对象改变时通知中介者的方法
   * 在同事对象改变时由中介者去通知其他的同事对象
   *
   * @param c 同事对象
   */
  public abstract void changed(Colleague c);
}

抽象同事：

public abstract class Colleague {
  protected Mediator mediator;//每一个同事都该知道其中介者
  public Colleague(Mediator mediator) {
    this.mediator = mediator;
  }
}

CPU同事：

public class CPU extends Colleague{
  private String dataVideo, dataSound; //视频和音频数据
  public CPU(Mediator mediator) {
    super(mediator);
  }
  /**
   * 获取视频数据
   *
   * @return 视频数据
   */
  public String getDataVideo(){
    return dataVideo;
  }
  /**
   * 获取音频数据
   *
   * @return 音频数据
   */
  public String getDataSound(){
    return dataSound;
  }
  /**
   * 解码数据
   *
   * @param data音、视频数据
   */
  public void decodeData(String data){
    //分割音、视频数据
    String[] tmp = data.split(",");
    //解析音、视频数据
    dataVideo = tmp[0];
    dataSound = tmp[1];
    //告诉中介者自身状态改变
    mediator.changed(this);
  }
}

光驱同事：

public class CDDevice extends Colleague{
  private String data; //视频数据
  public CDDevice(Mediator mediator) {
    super(mediator);
  }
  /**
   * 读取视频数据
   *
   * @return 视频数据
   */
  public String read(){
    return data;
  }
  /**
   * 加载视频数据
   *
   * @return 音频数据
   */
  public void load(){
    data = "视频数据,音频数据";
    //告诉中介者自身状态改变
    mediator.changed(this);
  }
}

显卡同事：

public class GraphicsCard extends Colleague{
  public GraphicsCard(Mediator mediator) {
    super(mediator);
  }
  /**
   * 播放视频数据
   *
   * @param 视频数据
   */
  public void videoPlay(String data){
    System.out.println("视频：" + data);
  }
}

声卡同事：

public class SoundCard extends Colleague{
  public SoundCard(Mediator mediator) {
    super(mediator);
  }
  /**
   * 播放音频数据
   *
   * @param 音频数据
   */
  public void soundPlay(String data){
    System.out.println("音频：" + data);
  }
}

主板中介者：

public class MainBoard extends Mediator{
  private CDDevice cdDevice; //光驱设备
  private CPU cpu; //CPU
  private SoundCard soundCard; //声卡设备
  private GraphicsCard graphicsCard; //显卡设备
  @Override
  public void changed(Colleague c) {
    //如果光驱读取了数据
    if(c == cdDevice){
      handleCD((CDDevice) c);
    }
    //如果CPU处理完数据
    else if(c == cpu){
      handleCD((CPU) c);
    }
  }
  /**
   * 处理光驱读取数据后与其他设备的交互
   *
   * @param cdDevice 光驱设备
   */
  public void handleCD(CDDevice cdDevice){
    cpu.decodeData(cdDevice.read());
  }
  /**
   * 处理CPU读取数据后与其他设备的交互
   *
   * @param cpu CPU
   */
  public void handleCD(CPU cpu){
    soundCard.soundPlay(cpu.getDataSound());
    graphicsCard.videoPlay(cpu.getDataVideo());
  }
  /**
   * 设置CD设备
   *
   * @param CDDevice CD设备
   */
  public void setCDDevice(CDDevice cdDevice){
    this.cdDevice = cdDevice;
  }
  /**
   * 设置CPU
   *
   * @param cpu CPU
   */
  public void setCPU(CPU cpu){
    this.cpu = cpu;
  }
  /**
   * 设置声卡设备
   *
   * @param soundCard 声卡设备
   */
  public void setSoundCard(SoundCard soundCard){
    this.soundCard = soundCard;
  }
  /**
   * 设置显卡设备
   *
   * @param graphicsCard 显卡设备
   */
  public void setGraphicsCard(GraphicsCard graphicsCard){
    this.graphicsCard = graphicsCard;
  }
}

播放电影：

public class Client {
  public static void main(String[] args) {
    //构造主板对象
    MainBoard mediator = new MainBoard();
    //分别构造各个零件
    CDDevice cd = new CDDevice(mediator);
    CPU cpu = new CPU(mediator);
    GraphicsCard gc = new GraphicsCard(mediator);
    SoundCard sc = new SoundCard(mediator);
    //将各个零件安装到主板
    mediator.setCDDevice(cd);
    mediator.setCPU(cpu);
    mediator.setGraphicsCard(gc);
    mediator.setSoundCard(sc);
    //播放电影
    cd.load();
  }
}

结果：

音频：音频数据
视频：视频数据

可以看出中介者模式将多对多的相互作用转化为一对多的相互作用，将系统从网状结构变为以中介者为中心的星形结构（这里就是主板），达到降低系统的复杂性，提高可扩展性。

六、Android源码中的中介者模式

1、Keyguard解锁屏

详细机制参考：Android4.0 Keyguard解锁屏机制

七、总结

其实在Android开发中我们可能无意间就使用了中介者模式，比如登录注册界面，我们使用EditText的addTextChangedListener监听输入密码的位数、用户名是否为空，密码与确认密码是否一致等等判断时，此时多个控件交互，就是由Activity充当中介者来协调。

优点：

适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。

使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。

使用中介者模式可以将对象间多对多的关联转变为一对多的关联，使对象间的关系易于理解和维护。

缺点：

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

更多关于Android相关内容感兴趣的读者可查看本站专题：《Android开发入门与进阶教程》、《Android调试技巧与常见问题解决方法汇总》、《Android基本组件用法总结》、《Android视图View技巧总结》、《Android布局layout技巧总结》及《Android控件用法总结》

希望本文所述对大家Android程序设计有所帮助。