设计模式 - 外观模式 facade

介绍

  • 1、使用频率高,常见的是第三方库。
  • 2、对外可见的只有一两个类,而内部涉及可能是个很庞大很复杂的系统。

定义

  • 1、 要求子系统的外部与其内部的通信必须通过一个统一的对象进行。
  • 2、 提供一个高层次的接口,是的子系统更易于使用。

使用场景

  • 1、某个模块很庞大或很复杂,希望外部能很简单就使用。
  • 2、希望控制把控入口,外部只能通过某个类来访问,这样以后要换方案就不会影响外部使用。

简单点:一个模块很复杂,但我们使用只需要一个类简单操作就可以了。

《设计模式 - 外观模式 facade》

形象的例子.png

再来举个例子吧

《设计模式 - 外观模式 facade》

举个例子

A:金矿是怎么挖出来的?
B:矿工到矿井里就挖呗
在外部只知道这些,但其实涉及到很多功能模块,这就是「外观模式」,让别人以为就是这么简单。

先看下涉及到的一些名词:

    1. Dwarven 矮人(霍比特中就是矮人来挖金矿的) DwarvenMineWorker 矮人旷工
    1. DwarvenTunnelDigger 挖隧道矮人
    1. DwarvenGoldDigger 挖金矿矮人
    1. DwarvenCartOperator 运输的矮人

我比较倾向于逆向看代码,也就是先看到结果,在顺藤摸瓜。那就先上结果:

public class App {
  public static void main(String[] args) {
    DwarvenGoldmineFacade facade = new DwarvenGoldmineFacade();
    facade.startNewDay();
    facade.digOutGold();
    facade.endDay();
  }
}

很简单,就是 new 一个 facade 出来,调用相应的方法,「开始新的一天」–>「挖矿」–>「结束」,结果:

DwarvenMineWorker - Dwarf gold digger wakes up.
DwarvenMineWorker - Dwarf gold digger goes to the mine.
DwarvenMineWorker - Dwarf cart operator wakes up.
DwarvenMineWorker - Dwarf cart operator goes to the mine.
DwarvenMineWorker - Dwarven tunnel digger wakes up.
DwarvenMineWorker - Dwarven tunnel digger goes to the mine.
DwarvenGoldDigger - Dwarf gold digger digs for gold.
DwarvenCartOperator - Dwarf cart operator moves gold chunks out of the mine.
DwarvenTunnelDigger - Dwarven tunnel digger creates another promising tunnel.
DwarvenMineWorker - Dwarf gold digger goes home.
DwarvenMineWorker - Dwarf gold digger goes to sleep.
DwarvenMineWorker - Dwarf cart operator goes home.
DwarvenMineWorker - Dwarf cart operator goes to sleep.
DwarvenMineWorker - Dwarven tunnel digger goes home.
DwarvenMineWorker - Dwarven tunnel digger goes to sleep.

看到这个过程由三个类型参与的,顺藤摸瓜,我们先看下 facade 类做了什么:

public class DwarvenGoldmineFacade {

  private final List<DwarvenMineWorker> workers;

  public DwarvenGoldmineFacade() {
    workers = new ArrayList<>();
    workers.add(new DwarvenGoldDigger());
    workers.add(new DwarvenCartOperator());
    workers.add(new DwarvenTunnelDigger());
  }

  public void startNewDay() {
    makeActions(workers, DwarvenMineWorker.Action.WAKE_UP, DwarvenMineWorker.Action.GO_TO_MINE);
  }

  public void digOutGold() {
    makeActions(workers, DwarvenMineWorker.Action.WORK);
  }

  public void endDay() {
    makeActions(workers, DwarvenMineWorker.Action.GO_HOME, DwarvenMineWorker.Action.GO_TO_SLEEP);
  }

  private static void makeActions(Collection<DwarvenMineWorker> workers,
      DwarvenMineWorker.Action... actions) {
    for (DwarvenMineWorker worker : workers) {
      worker.action(actions);
    }
  }
}

简单说明下,在构造中添加了三个类型的工作者,在每个动作中都会调用工作者的具体操作。

接着我们拿一个旷工矮人来看下具体实现:

public class DwarvenGoldDigger extends DwarvenMineWorker {

  private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenGoldDigger.class);

  @Override
  public void work() {
    LOGGER.info("{} digs for gold.", name());
  }

  @Override
  public String name() {
    return "Dwarf gold digger";
  }
}

可以看到只是实现了父类定义的抽象方法(显示名称、工作内容),那么接着看下父类的实现:

public abstract class DwarvenMineWorker {

  private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenMineWorker.class);

  public void goToSleep() {
    LOGGER.info("{} goes to sleep.", name());
  }

  public void wakeUp() {
    LOGGER.info("{} wakes up.", name());
  }

  public void goHome() {
    LOGGER.info("{} goes home.", name());
  }

  public void goToMine() {
    LOGGER.info("{} goes to the mine.", name());
  }

  private void action(Action action) {
    switch (action) {
      case GO_TO_SLEEP:
        goToSleep();
        break;
      case WAKE_UP:
        wakeUp();
        break;
      case GO_HOME:
        goHome();
        break;
      case GO_TO_MINE:
        goToMine();
        break;
      case WORK:
        work();
        break;
      default:
        LOGGER.info("Undefined action");
        break;
    }
  }

  // 执行任务
  public void action(Action... actions) {
    for (Action action : actions) {
      action(action);
    }
  }

  public abstract void work();

  public abstract String name();

  static enum Action {
    GO_TO_SLEEP, WAKE_UP, GO_HOME, GO_TO_MINE, WORK
  }
}

这个父类中提供了:醒来、去矿井、工作、回家、睡觉的操作.

在回头看下最开始,我们只是 DwarvenGoldmineFacade facade = new DwarvenGoldmineFacade();然后就调用一些操作 facade.startNewDay() ,就让整个矿场工作起来了。 对于外部, 可见的只是 DwarvenGoldmineFacade ,但内部可能是很复杂的操作。

还有另一个使用场景:整个功能模块用的 SDK 可能过不久换另一个 SDK 来实现。这时候我们也可以考虑使用「外观模式」来控制外界访问。更换时就不会影响到具体使用。

我们做开发时,一定要先做好需求分析,反复确认需求之后,选择适当的框架。在使用别人的库时,可以先自己封装一回,使用自己封装的类而不是直接使用别人的库。这样做得好处就是更换库不至于全盘都要修改。

当我们自己写个复杂的功能或系统供外部(也可以是自己)使用时,也可以考虑使用外观模式,让外部使用更简单,还能控制好出口。

参考:

  1. java-design-patterns
  2. Android源码设计模式解析与实战
    原文作者:算法小白
    原文地址: https://juejin.im/entry/59b8d4bc5188256c6c3e135d
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞