结构型模式：外观模式

什么是外观模式？

想象一下，你刚买了一套家庭影院系统，里面有DVD播放器、音响、投影仪、自动窗帘等设备。要看一部电影，你需要：

1. 打开电视和DVD播放器
2. 调低房间灯光
3. 放下投影幕布
4. 打开音响系统
5. 设置音响输入为DVD
6. 放入DVD并播放

太复杂了！如果有一个"看电影"按钮，按一下就能完成所有这些步骤，是不是会方便很多？

这就是外观模式的核心思想：为复杂的子系统提供一个简单的接口，让客户端更容易使用。外观模式就像是给复杂系统装了一个"简易操作面板"，隐藏了内部的复杂性。

外观模式的结构

外观模式的角色其实很简单：

1. 外观（Facade）：提供简化的接口，内部调用各个子系统
2. 子系统（Subsystem）：实现复杂功能的各个类
3. 客户端（Client）：通过外观来使用系统功能

下面是外观模式的类图：

生活中的外观模式例子

1. 餐厅点套餐

当你去快餐店点餐时：

• 不使用外观模式：分别点主食、配菜、饮料、甜点…
• 使用外观模式：直接点"套餐A"，一步到位

2. 洗衣机

洗衣机是家用电器中的外观模式典范：

• 不使用外观模式：手动设置水温、转速、浸泡时间、漂洗次数…
• 使用外观模式：选择"棉织物"模式，一键完成所有设置

代码示例：家庭影院系统

下面用家庭影院系统来展示外观模式，代码尽量简单：

// 各种家庭影院设备（子系统）
class Television {
    public void turnOn() {
        System.out.println("打开电视");
    }
    
    public void turnOff() {
        System.out.println("关闭电视");
    }
    
    public void setInputSource(String source) {
        System.out.println("设置电视输入源为：" + source);
    }
}

class DVDPlayer {
    public void turnOn() {
        System.out.println("打开DVD播放器");
    }
    
    public void turnOff() {
        System.out.println("关闭DVD播放器");
    }
    
    public void play(String movie) {
        System.out.println("播放电影：" + movie);
    }
    
    public void stop() {
        System.out.println("停止播放");
    }
}

class SoundSystem {
    public void turnOn() {
        System.out.println("打开音响系统");
    }
    
    public void turnOff() {
        System.out.println("关闭音响系统");
    }
    
    public void setVolume(int level) {
        System.out.println("设置音量为：" + level);
    }
}

class Lights {
    public void dim(int level) {
        System.out.println("将灯光调暗至" + level + "%");
    }
    
    public void brighten(int level) {
        System.out.println("将灯光调亮至" + level + "%");
    }
}

// 家庭影院外观类
class HomeTheaterFacade {
    private Television tv;
    private DVDPlayer dvdPlayer;
    private SoundSystem soundSystem;
    private Lights lights;
    
    // 构造函数，初始化所有设备
    public HomeTheaterFacade() {
        tv = new Television();
        dvdPlayer = new DVDPlayer();
        soundSystem = new SoundSystem();
        lights = new Lights();
    }
    
    // 简化的"看电影"功能
    public void watchMovie(String movie) {
        System.out.println("=== 准备观影 ===");
        lights.dim(10);             // 将灯光调暗到10%
        tv.turnOn();                // 打开电视
        tv.setInputSource("DVD");   // 设置输入源
        dvdPlayer.turnOn();         // 打开DVD播放器
        soundSystem.turnOn();       // 打开音响
        soundSystem.setVolume(60);  // 设置适中音量
        dvdPlayer.play(movie);      // 播放电影
        System.out.println("一切就绪，尽情享受电影吧！");
    }
    
    // 简化的"结束观影"功能
    public void endMovie() {
        System.out.println("=== 结束观影 ===");
        dvdPlayer.stop();           // 停止播放
        dvdPlayer.turnOff();        // 关闭DVD
        soundSystem.turnOff();      // 关闭音响
        tv.turnOff();               // 关闭电视
        lights.brighten(100);       // 灯光调亮
        System.out.println("家庭影院已关闭");
    }
}

// 客户端使用示例
public class HomeTheaterDemo {
    public static void main(String[] args) {
        // 创建家庭影院外观
        HomeTheaterFacade homeTheater = new HomeTheaterFacade();
        
        // 使用简化的接口看电影
        homeTheater.watchMovie("《长津湖》");
        
        System.out.println("\n电影播放中...\n");
        
        // 使用简化的接口结束观影
        homeTheater.endMovie();
        
        // 对比：如果不使用外观模式，客户端代码会很复杂
        System.out.println("\n=== 不使用外观模式的情况 ===");
        System.out.println("你需要了解每个设备，并按正确顺序调用至少10个不同方法！");
    }
}

另一个例子：点餐系统

外卖平台的下单流程是另一个很好的外观模式示例：

// 子系统：菜品管理
class MenuSystem {
    public boolean checkAvailability(String itemId) {
        System.out.println("检查菜品 " + itemId + " 是否有货");
        return true; // 假设都有货
    }
    
    public double getPrice(String itemId) {
        // 简化的价格查询
        System.out.println("获取菜品 " + itemId + " 的价格");
        if (itemId.equals("B001")) return 20.0;
        if (itemId.equals("F001")) return 38.0;
        if (itemId.equals("D001")) return 5.0;
        return 15.0;
    }
}

// 子系统：购物车
class CartSystem {
    public void addItem(String itemId, int quantity) {
        System.out.println("将 " + quantity + " 份 " + itemId + " 加入购物车");
    }
    
    public double calculateTotal(String[] items) {
        System.out.println("计算购物车总金额");
        // 简化的计算逻辑
        return 63.0; // 假设总价是63元
    }
}

// 子系统：支付处理
class PaymentSystem {
    public boolean processPayment(String paymentMethod, double amount) {
        System.out.println("使用" + paymentMethod + "支付 " + amount + " 元");
        return true; // 假设支付成功
    }
    
    public String generatePaymentReceipt() {
        return "PAY" + System.currentTimeMillis();
    }
}

// 子系统：订单管理
class OrderSystem {
    public String createOrder(String userId, String[] items) {
        System.out.println("为用户 " + userId + " 创建订单");
        return "ORD" + System.currentTimeMillis();
    }
    
    public void updateOrderStatus(String orderId, String status) {
        System.out.println("更新订单 " + orderId + " 状态为：" + status);
    }
}

// 外观：点餐服务
class FoodOrderFacade {
    private MenuSystem menuSystem;
    private CartSystem cartSystem;
    private PaymentSystem paymentSystem;
    private OrderSystem orderSystem;
    
    public FoodOrderFacade() {
        menuSystem = new MenuSystem();
        cartSystem = new CartSystem();
        paymentSystem = new PaymentSystem();
        orderSystem = new OrderSystem();
    }
    
    // 简化的一键下单方法
    public boolean placeOrder(String userId, String[] itemIds, String paymentMethod) {
        try {
            System.out.println("=== 开始一键下单 ===");
            
            // 1. 检查菜品是否可用并计算价格
            for (String itemId : itemIds) {
                if (!menuSystem.checkAvailability(itemId)) {
                    System.out.println("抱歉，菜品 " + itemId + " 已售罄");
                    return false;
                }
                // 将菜品加入购物车
                cartSystem.addItem(itemId, 1);
            }
            
            // 2. 计算总价
            double totalAmount = cartSystem.calculateTotal(itemIds);
            System.out.println("订单总金额：" + totalAmount + " 元");
            
            // 3. 创建订单
            String orderId = orderSystem.createOrder(userId, itemIds);
            
            // 4. 处理支付
            boolean paymentSuccess = paymentSystem.processPayment(paymentMethod, totalAmount);
            if (paymentSuccess) {
                // 5. 完成订单
                String receiptId = paymentSystem.generatePaymentReceipt();
                orderSystem.updateOrderStatus(orderId, "已支付");
                System.out.println("下单成功！订单号：" + orderId);
                System.out.println("支付凭证：" + receiptId);
                return true;
            } else {
                orderSystem.updateOrderStatus(orderId, "支付失败");
                System.out.println("支付失败，请重试");
                return false;
            }
            
        } catch (Exception e) {
            System.out.println("下单过程中出现错误：" + e.getMessage());
            return false;
        }
    }
}

// 客户端使用示例
public class FoodOrderDemo {
    public static void main(String[] args) {
        // 创建点餐外观
        FoodOrderFacade orderService = new FoodOrderFacade();
        
        // 准备点餐数据
        String userId = "user123";
        String[] items = {"B001", "F001", "D001"}; // 汉堡、炸鸡、可乐
        
        // 一键下单（注意这里客户端代码多么简单！）
        boolean success = orderService.placeOrder(userId, items, "微信支付");
        
        if (success) {
            System.out.println("\n恭喜，您的订单已成功下单，请等待送达！");
        } else {
            System.out.println("\n订单处理失败，请稍后重试。");
        }
        
        // 对比：如果不使用外观模式
        System.out.println("\n=== 不使用外观模式的情况 ===");
        System.out.println("客户端需要单独调用每个子系统：");
        System.out.println("1. 调用菜品系统检查每个菜品是否可用");
        System.out.println("2. 调用购物车系统添加菜品并计算总价");
        System.out.println("3. 调用订单系统创建订单");
        System.out.println("4. 调用支付系统处理支付");
        System.out.println("5. 获取支付凭证并更新订单状态");
        System.out.println("这太复杂了！");
    }
}

如何在现实项目中应用外观模式

五步轻松使用外观模式

1. 识别复杂性：找出系统中让用户感到繁琐的部分

   • 例如：需要多个类协作完成的任务
   • 例如：需要按特定顺序调用的一系列操作

2. 分析子系统：确定哪些类组成了复杂的子系统

   • 把相关功能的类整理出来
   • 了解它们之间的调用关系

3. 设计外观接口：从用户角度思考，他们真正需要的简化操作是什么

   • 例如：“看电影”、“下单”、"备份数据"等高层操作

4. 实现外观类：创建外观类，在里面组合各个子系统的调用

   • 初始化所需的子系统对象
   • 按正确顺序调用各个子系统的方法

5. 使用外观：客户端通过外观类来使用系统功能

   • 不再直接调用复杂的子系统
   • 代码更简洁、更易于维护

实际场景中的应用

1. App开发：使用外观模式简化复杂API的调用

   // 不使用外观模式
   LocationManager locManager = (LocationManager)getSystemService(LOCATION_SERVICE);
   Criteria criteria = new Criteria();
   criteria.setAccuracy(Criteria.ACCURACY_FINE);
   String provider = locManager.getBestProvider(criteria, true);
   Location location = locManager.getLastKnownLocation(provider);
   double lat = location.getLatitude();
   double lng = location.getLongitude();
   
   // 使用外观模式
   LocationFacade locationFacade = new LocationFacade(context);
   LatLng currentLocation = locationFacade.getCurrentLocation();
   

2. 企业应用：简化多系统协作的业务流程

   // 例如用户注册流程，不使用外观模式需要调用多个服务：
   // 1. 验证用户数据
   // 2. 保存用户信息到数据库
   // 3. 发送验证邮件
   // 4. 创建默认用户设置
   // 5. 记录审计日志
   
   // 使用外观模式
   UserRegistrationFacade registrationService = new UserRegistrationFacade();
   boolean success = registrationService.registerUser(userData);
   

外观模式的优缺点

优点

1. 简化接口：让复杂系统变得容易使用
2. 降低耦合：客户端不需要了解子系统的复杂细节
3. 提高可读性：代码更加清晰，体现了意图而非细节
4. 分层设计：帮助实现系统的分层设计

缺点

1. 可能变成"万能类"：如果不小心，外观类可能变得过于庞大
2. 新功能适配：每次子系统新增功能，可能需要更新外观类
3. 不够灵活：外观提供的简化接口可能无法满足特殊需求

什么时候应该使用外观模式

适合使用外观模式的情况：

1. 系统非常复杂，客户端需要调用多个子系统才能完成一项任务
2. 希望隐藏系统复杂性，只暴露必要的功能给客户端
3. 系统分层设计，需要一个入口点来访问某一层
4. 需要为复杂系统提供简单的API，方便其他开发者使用

外观模式与其他模式的对比

• 外观模式 vs 适配器模式：

  • 外观模式：简化接口，让系统更易用
  • 适配器模式：转换接口，让不兼容的接口能一起工作

• 外观模式 vs 中介者模式：

  • 外观模式：为客户端简化子系统调用
  • 中介者模式：处理系统内部对象之间的交互

小结：外观模式的精髓

外观模式本质上是一种"简化"的艺术。它就像日常生活中的遥控器、快捷键或APP，把复杂的操作变成一键式体验。实现外观模式不需要复杂的技术，关键在于：

1. 找出"繁琐"的地方
2. 设计"便捷"的接口
3. 在内部处理复杂性

记住这句话：“对外简单，对内处理复杂”，这就是外观模式的核心思想。

在你的下一个项目中，当你发现自己反复编写类似的复杂调用序列时，考虑一下是否可以引入外观模式，来让你的代码更简洁、更易懂、更好维护！