当前位置：首页 > news >正文

设计模式-外观模式详解

news 2025/9/19 8:03:14

外观模式详解

1. 外观模式简介

1.1 定义

外观模式（Facade Pattern）是一种结构型设计模式，它为子系统中的一组接口提供一个统一的接口。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

1.2 核心思想

简化接口：为复杂的子系统提供简单的接口
解耦：客户端与子系统解耦，降低依赖关系
统一入口：提供统一的访问入口
隐藏复杂性：隐藏子系统的内部复杂性

1.3 适用场景

为复杂的子系统提供简单接口
客户端与多个子系统之间存在强耦合
需要分层构建系统
需要为遗留系统提供新接口

1.4 外观模式结构

类图结构

核心组件

Facade（外观）：为子系统提供统一接口
SubSystem（子系统）：实现具体功能
Client（客户端）：通过外观访问子系统

1.5 外观模式分类

基本外观模式

// 子系统A
public class SubSystemA {public void operationA() {System.out.println("执行子系统A的操作");}
}// 子系统B
public class SubSystemB {public void operationB() {System.out.println("执行子系统B的操作");}
}// 子系统C
public class SubSystemC {public void operationC() {System.out.println("执行子系统C的操作");}
}// 外观类
public class Facade {private SubSystemA subSystemA;private SubSystemB subSystemB;private SubSystemC subSystemC;public Facade() {this.subSystemA = new SubSystemA();this.subSystemB = new SubSystemB();this.subSystemC = new SubSystemC();}// 统一接口public void operation() {System.out.println("外观模式开始执行");subSystemA.operationA();subSystemB.operationB();subSystemC.operationC();System.out.println("外观模式执行完成");}
}

抽象外观模式

// 抽象外观
public abstract class AbstractFacade {protected SubSystemA subSystemA;protected SubSystemB subSystemB;protected SubSystemC subSystemC;public AbstractFacade() {this.subSystemA = new SubSystemA();this.subSystemB = new SubSystemB();this.subSystemC = new SubSystemC();}public abstract void operation();
}// 具体外观A
public class ConcreteFacadeA extends AbstractFacade {@Overridepublic void operation() {System.out.println("外观A开始执行");subSystemA.operationA();subSystemB.operationB();System.out.println("外观A执行完成");}
}// 具体外观B
public class ConcreteFacadeB extends AbstractFacade {@Overridepublic void operation() {System.out.println("外观B开始执行");subSystemB.operationB();subSystemC.operationC();System.out.println("外观B执行完成");}
}

2. 核心流程

2.1 外观模式执行流程

2.2 外观模式设计流程

步骤1：识别复杂子系统

// 识别需要外观模式的复杂系统
public class ComplexSystem {// 用户管理子系统public class UserService {public void createUser() { /* 复杂逻辑 */ }public void updateUser() { /* 复杂逻辑 */ }public void deleteUser() { /* 复杂逻辑 */ }}// 订单管理子系统public class OrderService {public void createOrder() { /* 复杂逻辑 */ }public void updateOrder() { /* 复杂逻辑 */ }public void cancelOrder() { /* 复杂逻辑 */ }}// 支付管理子系统public class PaymentService {public void processPayment() { /* 复杂逻辑 */ }public void refundPayment() { /* 复杂逻辑 */ }public void queryPayment() { /* 复杂逻辑 */ }}// 库存管理子系统public class InventoryService {public void checkStock() { /* 复杂逻辑 */ }public void updateStock() { /* 复杂逻辑 */ }public void reserveStock() { /* 复杂逻辑 */ }}
}

步骤2：设计外观接口

// 设计统一的外观接口
public interface ECommerceFacade {// 用户相关操作void registerUser(String username, String email);void updateUserProfile(String userId, String profile);void deleteUser(String userId);// 订单相关操作String createOrder(String userId, List<String> products);void updateOrderStatus(String orderId, String status);void cancelOrder(String orderId);// 支付相关操作boolean processPayment(String orderId, double amount);boolean refundPayment(String orderId);PaymentStatus queryPaymentStatus(String orderId);// 库存相关操作boolean checkProductAvailability(String productId, int quantity);void updateProductStock(String productId, int quantity);void reserveProduct(String productId, int quantity);
}

步骤3：实现外观类

// 实现外观类
public class ECommerceFacadeImpl implements ECommerceFacade {private UserService userService;private OrderService orderService;private PaymentService paymentService;private InventoryService inventoryService;public ECommerceFacadeImpl() {this.userService = new UserService();this.orderService = new OrderService();this.paymentService = new PaymentService();this.inventoryService = new InventoryService();}@Overridepublic void registerUser(String username, String email) {System.out.println("开始用户注册流程");userService.createUser();System.out.println("用户注册完成");}@Overridepublic String createOrder(String userId, List<String> products) {System.out.println("开始创建订单流程");// 检查用户是否存在if (!userService.userExists(userId)) {throw new IllegalArgumentException("用户不存在");}// 检查库存for (String productId : products) {if (!inventoryService.checkProductAvailability(productId, 1)) {throw new IllegalStateException("产品库存不足: " + productId);}}// 创建订单String orderId = orderService.createOrder();// 预留库存for (String productId : products) {inventoryService.reserveProduct(productId, 1);}System.out.println("订单创建完成: " + orderId);return orderId;}@Overridepublic boolean processPayment(String orderId, double amount) {System.out.println("开始支付流程");// 验证订单if (!orderService.orderExists(orderId)) {throw new IllegalArgumentException("订单不存在");}// 处理支付boolean paymentResult = paymentService.processPayment();if (paymentResult) {// 更新订单状态orderService.updateOrderStatus(orderId, "PAID");System.out.println("支付成功");} else {// 释放预留库存inventoryService.releaseReservedStock(orderId);System.out.println("支付失败，已释放库存");}return paymentResult;}// 其他方法实现...
}

步骤4：客户端使用

// 客户端使用外观模式
public class ECommerceClient {public static void main(String[] args) {ECommerceFacade facade = new ECommerceFacadeImpl();try {// 用户注册facade.registerUser("张三", "zhangsan@example.com");// 创建订单List<String> products = Arrays.asList("PROD001", "PROD002");String orderId = facade.createOrder("USER001", products);// 处理支付boolean paymentSuccess = facade.processPayment(orderId, 100.0);if (paymentSuccess) {System.out.println("订单处理成功");} else {System.out.println("订单处理失败");}} catch (Exception e) {System.err.println("操作失败: " + e.getMessage());}}
}

2.3 外观模式变体

2.3.1 多外观模式

// 多个外观类，提供不同的接口
public class UserFacade {private UserService userService;private ProfileService profileService;public void manageUser(String userId) {// 用户管理相关操作}
}public class OrderFacade {private OrderService orderService;private InventoryService inventoryService;public void manageOrder(String orderId) {// 订单管理相关操作}
}public class PaymentFacade {private PaymentService paymentService;private RefundService refundService;public void managePayment(String paymentId) {// 支付管理相关操作}
}

2.3.2 外观模式与适配器模式结合

// 外观模式与适配器模式结合
public class LegacySystemFacade {private LegacyUserService legacyUserService;private LegacyOrderService legacyOrderService;private ModernUserService modernUserService;private ModernOrderService modernOrderService;// 适配器模式：将遗留系统适配到现代系统public void migrateUser(String userId) {// 从遗留系统获取用户数据LegacyUser legacyUser = legacyUserService.getUser(userId);// 转换为现代系统格式ModernUser modernUser = convertToModernUser(legacyUser);// 保存到现代系统modernUserService.saveUser(modernUser);}private ModernUser convertToModernUser(LegacyUser legacyUser) {// 转换逻辑return new ModernUser();}
}

3. 重难点分析

3.1 重难点一：外观模式的设计原则

难点分析

接口设计：如何设计简洁而完整的外观接口
职责划分：外观类应该承担多少职责
子系统管理：如何管理多个子系统的依赖关系
异常处理：如何处理子系统的异常

解决方案

// 良好的外观模式设计
public class WellDesignedFacade {// 1. 单一职责：每个方法只做一件事public void processOrder(String orderId) {validateOrder(orderId);checkInventory(orderId);processPayment(orderId);updateInventory(orderId);}// 2. 异常处理：统一的异常处理机制private void validateOrder(String orderId) {try {orderService.validateOrder(orderId);} catch (OrderValidationException e) {throw new FacadeException("订单验证失败", e);}}// 3. 依赖注入：通过构造函数注入依赖private final OrderService orderService;private final InventoryService inventoryService;private final PaymentService paymentService;public WellDesignedFacade(OrderService orderService, InventoryService inventoryService, PaymentService paymentService) {this.orderService = orderService;this.inventoryService = inventoryService;this.paymentService = paymentService;}// 4. 日志记录：统一的日志记录private void logOperation(String operation, String details) {logger.info("执行操作: {} - {}", operation, details);}
}

3.2 重难点二：外观模式与子系统的解耦

难点分析

紧耦合问题：外观类与子系统紧耦合
变更影响：子系统变更影响外观类
测试困难：难以单独测试外观类
扩展性差：难以添加新的子系统

解决方案

// 解耦的外观模式设计
public class DecoupledFacade {// 1. 使用接口抽象子系统private final UserServiceInterface userService;private final OrderServiceInterface orderService;private final PaymentServiceInterface paymentService;// 2. 通过构造函数注入依赖public DecoupledFacade(UserServiceInterface userService,OrderServiceInterface orderService,PaymentServiceInterface paymentService) {this.userService = userService;this.orderService = orderService;this.paymentService = paymentService;}// 3. 使用策略模式处理不同实现public void processOrder(String orderId, ProcessingStrategy strategy) {strategy.process(orderId, userService, orderService, paymentService);}
}// 子系统接口
public interface UserServiceInterface {void createUser(String userId);boolean userExists(String userId);
}public interface OrderServiceInterface {String createOrder(String userId);boolean orderExists(String orderId);void updateOrderStatus(String orderId, String status);
}// 处理策略接口
public interface ProcessingStrategy {void process(String orderId, UserServiceInterface userService,OrderServiceInterface orderService,PaymentServiceInterface paymentService);
}

3.3 重难点三：外观模式的性能优化

难点分析

性能瓶颈：外观类可能成为性能瓶颈
资源管理：如何管理子系统的资源
缓存策略：如何实现缓存机制
异步处理：如何支持异步操作

解决方案

// 高性能外观模式设计
public class HighPerformanceFacade {private final Map<String, Object> cache = new ConcurrentHashMap<>();private final ExecutorService executorService;private final CircuitBreaker circuitBreaker;public HighPerformanceFacade() {this.executorService = Executors.newFixedThreadPool(10);this.circuitBreaker = new CircuitBreaker();}// 1. 缓存机制public UserInfo getUserInfo(String userId) {String cacheKey = "user:" + userId;UserInfo cached = (UserInfo) cache.get(cacheKey);if (cached != null) {return cached;}UserInfo userInfo = userService.getUserInfo(userId);cache.put(cacheKey, userInfo);return userInfo;}// 2. 异步处理public CompletableFuture<OrderResult> processOrderAsync(String orderId) {return CompletableFuture.supplyAsync(() -> {try {return processOrder(orderId);} catch (Exception e) {throw new RuntimeException(e);}}, executorService);}// 3. 熔断器模式public boolean processPayment(String orderId, double amount) {return circuitBreaker.execute(() -> {return paymentService.processPayment(orderId, amount);});}// 4. 资源管理public void shutdown() {executorService.shutdown();try {if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {executorService.shutdownNow();}} catch (InterruptedException e) {executorService.shutdownNow();}}
}

3.4 重难点四：外观模式的测试

难点分析

集成测试：如何测试外观类与子系统的集成
单元测试：如何单独测试外观类
Mock测试：如何使用Mock对象测试
性能测试：如何测试外观类的性能

解决方案

// 外观模式测试
public class FacadeTest {@Testpublic void testProcessOrder() {// 1. 创建Mock对象UserService mockUserService = Mockito.mock(UserService.class);OrderService mockOrderService = Mockito.mock(OrderService.class);PaymentService mockPaymentService = Mockito.mock(PaymentService.class);// 2. 设置Mock行为when(mockUserService.userExists("USER001")).thenReturn(true);when(mockOrderService.createOrder()).thenReturn("ORDER001");when(mockPaymentService.processPayment()).thenReturn(true);// 3. 创建外观对象ECommerceFacade facade = new ECommerceFacadeImpl(mockUserService, mockOrderService, mockPaymentService);// 4. 执行测试String orderId = facade.createOrder("USER001", Arrays.asList("PROD001"));// 5. 验证结果assertEquals("ORDER001", orderId);verify(mockUserService).userExists("USER001");verify(mockOrderService).createOrder();}@Testpublic void testProcessOrderWithException() {// 测试异常情况UserService mockUserService = Mockito.mock(UserService.class);when(mockUserService.userExists("USER001")).thenReturn(false);ECommerceFacade facade = new ECommerceFacadeImpl(mockUserService, null, null);assertThrows(IllegalArgumentException.class, () -> {facade.createOrder("USER001", Arrays.asList("PROD001"));});}@Testpublic void testPerformance() {// 性能测试ECommerceFacade facade = new ECommerceFacadeImpl();long startTime = System.currentTimeMillis();for (int i = 0; i < 1000; i++) {facade.processOrder("ORDER" + i);}long endTime = System.currentTimeMillis();assertTrue(endTime - startTime < 5000); // 5秒内完成}
}

4. Spring中的源码分析

4.1 Spring中的外观模式应用

4.1.1 Spring MVC中的DispatcherServlet

// DispatcherServlet作为外观模式的应用
public class DispatcherServlet extends FrameworkServlet {// 外观方法：处理HTTP请求@Overrideprotected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {if (logger.isDebugEnabled()) {String requestUri = urlPathHelper.getRequestUri(request);logger.debug("DispatcherServlet with name '" + getServletName() + "' processing " + request.getMethod() + " request for [" + requestUri + "]");}// 设置请求属性request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);try {// 核心外观方法doDispatch(request, response);} finally {if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {if (attributesSnapshot != null) {restoreAttributesAfterInclude(request, attributesSnapshot);}}}}// 核心外观方法：统一处理请求protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {HttpServletRequest processedRequest = request;HandlerExecutionChain mappedHandler = null;boolean multipartRequestParsed = false;WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);try {ModelAndView mv = null;Exception dispatchException = null;try {// 1. 检查是否为文件上传请求processedRequest = checkMultipart(request);multipartRequestParsed = (processedRequest != request);// 2. 确定处理器mappedHandler = getHandler(processedRequest);if (mappedHandler == null) {noHandlerFound(processedRequest, response);return;}// 3. 确定处理器适配器HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());// 4. 处理拦截器String method = request.getMethod();boolean isGet = "GET".equals(method);if (isGet || "HEAD".equals(method)) {long lastModified = ha.getLastModified(request, mappedHandler.getHandler());if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {return;}}if (!mappedHandler.applyPreHandle(processedRequest, response)) {return;}// 5. 实际调用处理器mv = ha.handle(processedRequest, response, mappedHandler.getHandler());if (asyncManager.isConcurrentHandlingStarted()) {return;}// 6. 应用默认视图名称applyDefaultViewName(processedRequest, mv);mappedHandler.applyPostHandle(processedRequest, response, mv);} catch (Exception ex) {dispatchException = ex;} catch (Throwable err) {dispatchException = new NestedServletException("Handler dispatch failed", err);}// 7. 处理结果processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);} catch (Exception ex) {triggerAfterCompletion(processedRequest, response, mappedHandler, ex);} catch (Throwable err) {triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler dispatch failed", err));} finally {if (asyncManager.isConcurrentHandlingStarted()) {if (mappedHandler != null) {mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);}} else {if (multipartRequestParsed) {cleanupMultipart(processedRequest);}}}}
}

4.1.2 Spring Security中的SecurityContextHolder

// SecurityContextHolder作为外观模式的应用
public final class SecurityContextHolder {public static final String MODE_THREADLOCAL = "MODE_THREADLOCAL";public static final String MODE_INHERITABLETHREADLOCAL = "MODE_INHERITABLETHREADLOCAL";public static final String MODE_GLOBAL = "MODE_GLOBAL";private static SecurityContextHolderStrategy strategy;private static int initializeCount = 0;static {initialize();}// 外观方法：获取当前安全上下文public static SecurityContext getContext() {return strategy.getContext();}// 外观方法：设置安全上下文public static void setContext(SecurityContext context) {strategy.setContext(context);}// 外观方法：清除安全上下文public static void clearContext() {strategy.clearContext();}// 外观方法：获取当前认证信息public static Authentication getAuthentication() {SecurityContext ctx = getContext();if (ctx == null) {return null;}return ctx.getAuthentication();}// 外观方法：设置当前认证信息public static void setAuthentication(Authentication authentication) {SecurityContext ctx = getContext();if (ctx == null) {ctx = createEmptyContext();setContext(ctx);}ctx.setAuthentication(authentication);}// 外观方法：创建空的安全上下文public static SecurityContext createEmptyContext() {return strategy.createEmptyContext();}// 初始化策略private static void initialize() {if (!StringUtils.hasText(strategyName)) {strategyName = MODE_THREADLOCAL;}if (strategyName.equals(MODE_THREADLOCAL)) {strategy = new ThreadLocalSecurityContextHolderStrategy();} else if (strategyName.equals(MODE_INHERITABLETHREADLOCAL)) {strategy = new InheritableThreadLocalSecurityContextHolderStrategy();} else if (strategyName.equals(MODE_GLOBAL)) {strategy = new GlobalSecurityContextHolderStrategy();} else {try {Class<?> clazz = Class.forName(strategyName);Constructor<?> customStrategy = clazz.getConstructor();strategy = (SecurityContextHolderStrategy) customStrategy.newInstance();} catch (Exception ex) {ReflectionUtils.handleReflectionException(ex);}}initializeCount++;}
}

4.1.3 Spring Data JPA中的JpaRepository

// JpaRepository作为外观模式的应用
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {// 外观方法：查找所有实体List<T> findAll();// 外观方法：根据ID查找实体List<T> findAllById(Iterable<ID> ids);// 外观方法：保存实体<S extends T> List<S> saveAll(Iterable<S> entities);// 外观方法：刷新实体void flush();// 外观方法：保存并刷新<S extends T> S saveAndFlush(S entity);// 外观方法：批量删除void deleteInBatch(Iterable<T> entities);// 外观方法：删除所有void deleteAllInBatch();// 外观方法：获取实体引用T getOne(ID id);// 外观方法：根据示例查询<S extends T> List<S> findAll(Example<S> example);// 外观方法：根据示例查询并排序<S extends T> List<S> findAll(Example<S> example, Sort sort);
}

4.2 Spring外观模式的特点

4.2.1 外观模式设计特点

统一接口：为复杂子系统提供简单接口
解耦设计：客户端与子系统解耦
分层架构：支持分层构建系统
扩展性好：易于添加新功能

4.2.2 Spring中外观模式的应用场景

// Spring中外观模式的应用场景
public class SpringFacadeExamples {// 1. Web层外观：DispatcherServletpublic void webLayerFacade() {// DispatcherServlet作为Web层的外观// 统一处理HTTP请求，协调各个组件}// 2. 安全层外观：SecurityContextHolderpublic void securityLayerFacade() {// SecurityContextHolder作为安全层的外观// 提供统一的安全上下文访问接口}// 3. 数据层外观：JpaRepositorypublic void dataLayerFacade() {// JpaRepository作为数据层的外观// 提供统一的数据访问接口}// 4. 事务层外观：TransactionTemplatepublic void transactionLayerFacade() {// TransactionTemplate作为事务层的外观// 提供统一的事务管理接口}
}

5. 面试高频点

5.1 基础概念类问题

Q1: 什么是外观模式？有什么特点？

答案要点：

定义：为子系统提供统一接口的结构型模式
特点：简化接口、解耦、统一入口、隐藏复杂性
核心：外观类 + 子系统 + 客户端

Q2: 外观模式与适配器模式的区别？

答案要点：

外观模式：为子系统提供统一接口
适配器模式：将不兼容的接口转换为兼容接口
目的不同：外观模式简化接口，适配器模式转换接口
使用场景：外观模式用于系统集成，适配器模式用于接口兼容

5.2 设计原理类问题

Q3: 外观模式的核心组件有哪些？

答案要点：

1. Facade（外观类）- 为子系统提供统一接口- 协调各个子系统的交互- 隐藏子系统的复杂性2. SubSystem（子系统）- 实现具体功能- 可以被外观类调用- 保持相对独立3. Client（客户端）- 通过外观类访问子系统- 不需要了解子系统细节- 简化了使用复杂度

Q4: 外观模式如何实现解耦？

答案要点：

接口抽象：通过接口抽象子系统
依赖注入：通过构造函数注入依赖
策略模式：使用策略模式处理不同实现
工厂模式：使用工厂模式创建子系统实例

5.3 实现细节类问题

Q5: 如何设计一个好的外观模式？

答案要点：

// 设计原则
1. 单一职责：每个方法只做一件事
2. 接口简洁：提供简洁而完整的接口
3. 异常处理：统一的异常处理机制
4. 依赖注入：通过构造函数注入依赖
5. 日志记录：统一的日志记录
6. 性能优化：考虑性能优化策略

Q6: 外观模式如何处理异常？

答案要点：

统一异常处理：在外观类中统一处理异常
异常转换：将子系统异常转换为业务异常
异常传播：合理传播异常信息
异常恢复：提供异常恢复机制

5.4 Spring应用类问题

Q7: Spring中哪些地方使用了外观模式？

答案要点：

1. DispatcherServlet：Web层外观
2. SecurityContextHolder：安全层外观
3. JpaRepository：数据层外观
4. TransactionTemplate：事务层外观
5. ApplicationContext：应用上下文外观
6. RestTemplate：HTTP客户端外观

Q8: Spring的DispatcherServlet是如何使用外观模式的？

答案要点：

// 核心流程
1. 接收HTTP请求
2. 确定处理器（Handler）
3. 确定处理器适配器（HandlerAdapter）
4. 处理拦截器（Interceptor）
5. 调用处理器（Handler）
6. 处理结果（View）
7. 返回响应

5.5 实际应用类问题

Q9: 在项目中如何应用外观模式？

答案要点：

// 应用场景
1. 系统集成：集成多个子系统
2. 服务封装：封装复杂的服务调用
3. 接口简化：简化复杂的接口
4. 遗留系统：为遗留系统提供新接口
5. 微服务：微服务间的服务调用

Q10: 外观模式的优缺点是什么？

答案要点：
优点：

简化接口，降低使用复杂度
解耦客户端与子系统
提供统一入口
隐藏子系统复杂性
易于维护和扩展

缺点：

可能成为性能瓶颈
增加了系统复杂度
可能违反单一职责原则
难以测试和调试
可能过度设计

5.6 源码分析类问题

Q11: Spring的SecurityContextHolder是如何设计的？

答案要点：

// 设计特点
1. 使用策略模式：支持不同的存储策略
2. 线程安全：使用ThreadLocal存储
3. 统一接口：提供统一的安全上下文访问
4. 可配置：支持不同的配置模式
5. 性能优化：避免频繁的对象创建

Q12: 如何测试外观模式？

答案要点：

// 测试策略
1. 单元测试：使用Mock对象测试外观类
2. 集成测试：测试外观类与子系统的集成
3. 性能测试：测试外观类的性能
4. 异常测试：测试异常处理机制
5. 并发测试：测试并发访问情况

5.7 设计模式对比类问题

Q13: 外观模式与其他模式的区别？

答案要点：

模式	关系	区别
适配器模式	结构型	转换接口 vs 简化接口
代理模式	结构型	控制访问 vs 简化访问
装饰器模式	结构型	增强功能 vs 简化功能
中介者模式	行为型	协调对象 vs 协调子系统

Q14: 什么时候使用外观模式？

答案要点：

// 使用场景判断
if (系统有多个子系统) {if (客户端需要访问多个子系统) {if (子系统接口复杂) {if (需要简化客户端使用) {使用外观模式;}}}
}// 具体场景
1. 系统集成：集成多个子系统
2. 服务封装：封装复杂的服务调用
3. 接口简化：简化复杂的接口
4. 遗留系统：为遗留系统提供新接口
5. 微服务：微服务间的服务调用