设计模式十一：外观模式（Facade Pattern）

外观模式（Facade Pattern）是一种结构型设计模式，它提供了一个统一的接口，用于访问系统中的一组复杂子系统。外观模式通过将复杂子系统的接口封装在一个高层接口中，简化了客户端与子系统之间的交互，使得客户端代码更加清晰、简洁。

外观模式的使用场景包括：

1. 简化复杂子系统的调用：当一个系统中存在多个复杂的子系统时，可以使用外观模式将这些子系统封装起来，提供一个简单的接口给客户端使用。这样客户端就不需要直接与复杂子系统进行交互，从而简化了调用过程。
2. 隔离变化：当系统中的子系统发生变化时，如果客户端与子系统直接耦合在一起，可能会导致大量的代码修改。而通过外观模式，只需要调整外观类即可，客户端无需做出任何修改，从而隔离了子系统变化对客户端的影响。
3. 提供统一的接口：当系统中存在多个较为复杂的接口和协议时，可以使用外观模式将这些接口和协议封装成一个简单的接口，方便客户端进行调用。这样客户端无需关心具体的实现细节，只需要与外观接口进行交互即可。
4. 构建分层结构系统：当系统需要采用分层结构时，可以使用外观模式建立各个层之间的联系。每个层的外观类作为对外的接口，隐藏了底层的实现细节，提供了一种简化的方式进行系统开发和维护。

外观模式中的主要角色有以下几个：

1. 外观（Facade）：外观角色是外部客户端访问复杂子系统的入口点。它封装了底层子系统的复杂性，提供了一个简单的接口供客户端使用。外观角色知道应该如何将客户端的请求委派给适当的子系统对象来进行处理。
2. 子系统（Subsystem）：子系统角色包含一组相关的类或接口，实现了子系统的具体功能。每个子系统都负责处理来自外观的请求，并根据需要执行相应的操作。外观将这些请求委派给合适的子系统对象来完成实际的工作。
3. 客户端（Client）：客户端角色通过调用外观角色提供的简化接口来间接地访问子系统的功能。客户端并不直接与子系统交互，而是通过外观角色来完成需要的操作。
   外观角色起到了协调和封装的作用，隐藏了子系统的复杂性，使得客户端可以更方便地使用子系统的功能。同时，子系统角色通过提供具体的实现来满足外观角色的请求。客户端角色则通过与外观角色进行交互间接地使用子系统的功能。

java代码举例

以外卖送货为例，根据业务分别将制作食物，运输方式，顾客信息拆分成三个服务，做一个外观模式，这三个服务集合在一起暴露一个对外接口
子系统：

/**
 * 制作Coffee
 */
public class Coffee {
    public String getCoffee(String coffeeType) {
        return "1.The " + coffeeType + " is ready ;";
    }
}

/**
 * 顾客信息
 */
public class Customer {
    public String getCustomerInfo(String customerName) {
        return "3:Deliver to " + customerName + ";";
    }
}

/**
 * 运输方式
 */
public class Transport {
    public String getTransport(String transportType) {
        return "2.Choose " + transportType + ";";
    }
}

外观：

/**
 * 外观类
 * 集成制作Coffee，选择对应的运输方式，并送达到指定顾客手中
 */
public class CoffeeFacade {

    private Coffee coffee;
    private Transport transport;
    private Customer customer;

    public CoffeeFacade() {
        this.coffee = new Coffee();
        this.transport = new Transport();
        this.customer = new Customer();
    }

    public String getCoffee(String coffeeType, String transportType, String customerName) {
        StringBuilder sb = new StringBuilder();
        sb.append(coffee.getCoffee(coffeeType));
        sb.append(transport.getTransport(transportType));
        sb.append(customer.getCustomerInfo(customerName));
        return sb.toString();
    }

客户端：

/**
 * 模拟客户端
 */
public class Facade {

    public static void main(String[] args) {
        CoffeeFacade facade = new CoffeeFacade();
        String starbucks = facade.getCoffee("Starbucks", "take-out", "li-hong-wang");
        System.out.println(starbucks);
    }
}

运行结果

1.The Starbucks is ready ;
2.Choose take-out;
3:Deliver to li-hong-wang;

外观模式的优缺点

优点：

1. 简化接口：外观模式通过封装复杂子系统的接口，提供了一个简化且统一的接口给客户端使用。这样可以降低客户端与子系统之间的耦合度，并且减少了客户端需要了解的知识。
2. 隐藏实现细节：外观模式将复杂子系统的实现细节隐藏在后面，使得客户端不需要关心复杂的内部操作过程，只需通过外观对象进行简单的调用即可。
3. 提高灵活性：通过外观模式，可以随时更改或扩展复杂子系统的实现，而不会影响到客户端代码。对于客户端来说，只要外观接口不发生变化，就不需要做任何修改。
4. 降低依赖性：外观模式将客户端与子系统解耦，减少了客户端直接依赖于多个子系统的情况。这样可以减少代码的耦合度，并提高代码的可维护性和可测试性。

缺点：

1. 过度增加外观类：如果系统中的子系统非常复杂，可能会导致外观类变得庞大而复杂。这样就会破坏了外观模式的简化和封装的初衷。
2. 不符合开闭原则：当需要新增或修改子系统时，可能需要修改外观类的代码。这可能会导致外观类的频繁修改，违反了开闭原则。