介绍

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

定义

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

使用场景

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

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

形象的例子.png

再来举个例子吧

举个例子

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源码设计模式解析与实战