外观模式

什么是外观模式？

外观模式（Facade Pattern）是一种结构型设计模式，它为复杂的子系统提供了一个简单的接口。简单来说，外观模式就像是一个"门面"，它隐藏了系统内部的复杂性，为用户提供了一个简单易用的接口。

为什么需要外观模式？

想象一下，如果你要开一家咖啡店，顾客只需要说"我要一杯拿铁"，而不需要知道：

如何操作咖啡机
如何调配牛奶
如何控制温度
如何清洗设备

咖啡师（外观）会处理所有这些复杂的操作，顾客只需要一个简单的接口。

外观模式的结构

客户端 → 外观类 → 子系统A
                → 子系统B
                → 子系统C

优点和缺点

优点

简化接口：客户端不需要了解复杂的子系统
降低耦合：客户端与子系统解耦
提高可维护性：修改子系统不影响客户端

缺点

违反开闭原则：新增功能可能需要修改外观类
可能产生"上帝类"：外观类可能变得过于复杂

示例一：家庭影院系统

问题描述

家庭影院系统包含多个复杂的设备：DVD 播放器、投影仪、音响、灯光等。用户需要分别操作每个设备，非常麻烦。

解决方案

使用外观模式，创建一个"家庭影院外观"来统一管理所有设备。

// 子系统：DVD播放器
class DVDPlayer {
    public void on() {
        System.out.println("DVD播放器开启");
    }

    public void play(String movie) {
        System.out.println("播放电影：" + movie);
    }

    public void off() {
        System.out.println("DVD播放器关闭");
    }
}

// 子系统：投影仪
class Projector {
    public void on() {
        System.out.println("投影仪开启");
    }

    public void setInput(String input) {
        System.out.println("设置输入源：" + input);
    }

    public void off() {
        System.out.println("投影仪关闭");
    }
}

// 子系统：音响
class Stereo {
    public void on() {
        System.out.println("音响开启");
    }

    public void setVolume(int volume) {
        System.out.println("设置音量：" + volume);
    }

    public void off() {
        System.out.println("音响关闭");
    }
}

// 子系统：灯光
class Lights {
    public void dim() {
        System.out.println("灯光调暗");
    }

    public void bright() {
        System.out.println("灯光调亮");
    }
}

// 外观类：家庭影院外观
class HomeTheaterFacade {
    private DVDPlayer dvdPlayer;
    private Projector projector;
    private Stereo stereo;
    private Lights lights;

    public HomeTheaterFacade() {
        this.dvdPlayer = new DVDPlayer();
        this.projector = new Projector();
        this.stereo = new Stereo();
        this.lights = new Lights();
    }

    // 看电影的简单接口
    public void watchMovie(String movie) {
        System.out.println("=== 准备看电影 ===");
        lights.dim();
        projector.on();
        projector.setInput("DVD");
        stereo.on();
        stereo.setVolume(10);
        dvdPlayer.on();
        dvdPlayer.play(movie);
    }

    // 结束电影的简单接口
    public void endMovie() {
        System.out.println("=== 结束看电影 ===");
        dvdPlayer.off();
        stereo.off();
        projector.off();
        lights.bright();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        HomeTheaterFacade homeTheater = new HomeTheaterFacade();

        // 用户只需要调用简单的方法
        homeTheater.watchMovie("星球大战");
        System.out.println();
        homeTheater.endMovie();
    }
}

运行结果

=== 准备看电影 ===
灯光调暗
投影仪开启
设置输入源：DVD
音响开启
设置音量：10
DVD播放器开启
播放电影：星球大战

=== 结束看电影 ===
DVD播放器关闭
音响关闭
投影仪关闭
灯光调亮

示例二：银行开户系统

问题描述

银行开户需要经过多个部门的处理：身份验证、风险评估、账户创建、卡片制作等。每个步骤都很复杂。

解决方案

使用外观模式，创建一个"银行服务外观"来简化开户流程。

// 子系统：身份验证服务
class IdentityVerificationService {
    public boolean verifyIdentity(String idCard, String name) {
        System.out.println("验证身份信息：" + name + "，身份证：" + idCard);
        // 模拟验证过程
        return true;
    }
}

// 子系统：风险评估服务
class RiskAssessmentService {
    public int assessRisk(String idCard) {
        System.out.println("进行风险评估，身份证：" + idCard);
        // 模拟风险评估
        return 1; // 1-低风险，2-中风险，3-高风险
    }
}

// 子系统：账户管理服务
class AccountManagementService {
    public String createAccount(String name, String idCard) {
        String accountNumber = "ACC" + System.currentTimeMillis();
        System.out.println("为 " + name + " 创建账户：" + accountNumber);
        return accountNumber;
    }
}

// 子系统：卡片服务
class CardService {
    public String issueCard(String accountNumber, String name) {
        String cardNumber = "CARD" + System.currentTimeMillis();
        System.out.println("为账户 " + accountNumber + " 发行卡片：" + cardNumber);
        return cardNumber;
    }
}

// 外观类：银行服务外观
class BankServiceFacade {
    private IdentityVerificationService identityService;
    private RiskAssessmentService riskService;
    private AccountManagementService accountService;
    private CardService cardService;

    public BankServiceFacade() {
        this.identityService = new IdentityVerificationService();
        this.riskService = new RiskAssessmentService();
        this.accountService = new AccountManagementService();
        this.cardService = new CardService();
    }

    // 开户的简单接口
    public AccountInfo openAccount(String name, String idCard) {
        System.out.println("=== 开始开户流程 ===");

        // 1. 身份验证
        if (!identityService.verifyIdentity(idCard, name)) {
            throw new RuntimeException("身份验证失败");
        }

        // 2. 风险评估
        int riskLevel = riskService.assessRisk(idCard);
        if (riskLevel > 2) {
            throw new RuntimeException("风险评估不通过");
        }

        // 3. 创建账户
        String accountNumber = accountService.createAccount(name, idCard);

        // 4. 发行卡片
        String cardNumber = cardService.issueCard(accountNumber, name);

        System.out.println("=== 开户成功 ===");

        return new AccountInfo(name, accountNumber, cardNumber);
    }
}

// 账户信息类
class AccountInfo {
    private String name;
    private String accountNumber;
    private String cardNumber;

    public AccountInfo(String name, String accountNumber, String cardNumber) {
        this.name = name;
        this.accountNumber = accountNumber;
        this.cardNumber = cardNumber;
    }

    // getter方法
    public String getName() { return name; }
    public String getAccountNumber() { return accountNumber; }
    public String getCardNumber() { return cardNumber; }

    @Override
    public String toString() {
        return "账户信息{" +
                "姓名='" + name + '\'' +
                ", 账户号='" + accountNumber + '\'' +
                ", 卡号='" + cardNumber + '\'' +
                '}';
    }
}

// 客户端代码
public class BankClient {
    public static void main(String[] args) {
        BankServiceFacade bankService = new BankServiceFacade();

        try {
            // 用户只需要调用一个方法就能完成开户
            AccountInfo account = bankService.openAccount("张三", "110101199001011234");
            System.out.println("开户结果：" + account);
        } catch (Exception e) {
            System.out.println("开户失败：" + e.getMessage());
        }
    }
}

运行结果

=== 开始开户流程 ===
验证身份信息：张三，身份证：110101199001011234
进行风险评估，身份证：110101199001011234
为 张三 创建账户：ACC1703123456789
为账户 ACC1703123456789 发行卡片：CARD1703123456790
=== 开户成功 ===
开户结果：账户信息{姓名='张三', 账户号='ACC1703123456789', 卡号='CARD1703123456790'}

示例三：在线购物系统

问题描述

在线购物涉及多个复杂的子系统：库存管理、支付处理、物流配送、用户通知等。

解决方案

使用外观模式简化购物流程。

// 子系统：库存管理
class InventoryService {
    public boolean checkStock(String productId, int quantity) {
        System.out.println("检查商品 " + productId + " 库存，需要数量：" + quantity);
        return true; // 假设库存充足
    }

    public void updateStock(String productId, int quantity) {
        System.out.println("更新商品 " + productId + " 库存，减少数量：" + quantity);
    }
}

// 子系统：支付处理
class PaymentService {
    public boolean processPayment(String orderId, double amount) {
        System.out.println("处理订单 " + orderId + " 的支付，金额：" + amount);
        return true; // 假设支付成功
    }
}

// 子系统：物流配送
class ShippingService {
    public String createShipment(String orderId, String address) {
        String trackingNumber = "TRK" + System.currentTimeMillis();
        System.out.println("为订单 " + orderId + " 创建物流单号：" + trackingNumber);
        return trackingNumber;
    }
}

// 子系统：用户通知
class NotificationService {
    public void sendOrderConfirmation(String orderId, String email) {
        System.out.println("向 " + email + " 发送订单确认邮件，订单号：" + orderId);
    }

    public void sendShippingNotification(String trackingNumber, String email) {
        System.out.println("向 " + email + " 发送物流通知，物流单号：" + trackingNumber);
    }
}

// 外观类：购物服务外观
class ShoppingFacade {
    private InventoryService inventoryService;
    private PaymentService paymentService;
    private ShippingService shippingService;
    private NotificationService notificationService;

    public ShoppingFacade() {
        this.inventoryService = new InventoryService();
        this.paymentService = new PaymentService();
        this.shippingService = new ShippingService();
        this.notificationService = new NotificationService();
    }

    // 下单的简单接口
    public OrderResult placeOrder(String productId, int quantity,
                                 double price, String address, String email) {
        System.out.println("=== 开始下单流程 ===");

        String orderId = "ORDER" + System.currentTimeMillis();
        double totalAmount = price * quantity;

        // 1. 检查库存
        if (!inventoryService.checkStock(productId, quantity)) {
            throw new RuntimeException("库存不足");
        }

        // 2. 处理支付
        if (!paymentService.processPayment(orderId, totalAmount)) {
            throw new RuntimeException("支付失败");
        }

        // 3. 更新库存
        inventoryService.updateStock(productId, quantity);

        // 4. 创建物流
        String trackingNumber = shippingService.createShipment(orderId, address);

        // 5. 发送通知
        notificationService.sendOrderConfirmation(orderId, email);
        notificationService.sendShippingNotification(trackingNumber, email);

        System.out.println("=== 下单成功 ===");

        return new OrderResult(orderId, trackingNumber, totalAmount);
    }
}

// 订单结果类
class OrderResult {
    private String orderId;
    private String trackingNumber;
    private double totalAmount;

    public OrderResult(String orderId, String trackingNumber, double totalAmount) {
        this.orderId = orderId;
        this.trackingNumber = trackingNumber;
        this.totalAmount = totalAmount;
    }

    // getter方法
    public String getOrderId() { return orderId; }
    public String getTrackingNumber() { return trackingNumber; }
    public double getTotalAmount() { return totalAmount; }

    @Override
    public String toString() {
        return "订单结果{" +
                "订单号='" + orderId + '\'' +
                ", 物流单号='" + trackingNumber + '\'' +
                ", 总金额=" + totalAmount +
                '}';
    }
}

// 客户端代码
public class ShoppingClient {
    public static void main(String[] args) {
        ShoppingFacade shoppingService = new ShoppingFacade();

        try {
            // 用户只需要调用一个方法就能完成下单
            OrderResult result = shoppingService.placeOrder(
                "PROD001", 2, 99.99, "北京市朝阳区", "user@example.com"
            );
            System.out.println("下单结果：" + result);
        } catch (Exception e) {
            System.out.println("下单失败：" + e.getMessage());
        }
    }
}

运行结果

=== 开始下单流程 ===
检查商品 PROD001 库存，需要数量：2
处理订单 ORDER1703123456791 的支付，金额：199.98
更新商品 PROD001 库存，减少数量：2
为订单 ORDER1703123456791 创建物流单号：TRK1703123456792
向 user@example.com 发送订单确认邮件，订单号：ORDER1703123456791
向 user@example.com 发送物流通知，物流单号：TRK1703123456792
=== 下单成功 ===
下单结果：订单结果{订单号='ORDER1703123456791', 物流单号='TRK1703123456792', 总金额=199.98}

总结

外观模式的核心思想是简化复杂系统的使用。它通过提供一个统一的接口，隐藏了子系统的复杂性，让客户端能够更容易地使用系统。

适用场景

需要简化复杂系统的使用
需要将系统分层，降低耦合
需要为复杂子系统提供一个简单接口

设计原则

最少知识原则：客户端只需要知道外观类，不需要了解子系统
单一职责原则：外观类负责简化接口，子系统负责具体功能

通过外观模式，我们可以让复杂的系统变得简单易用，就像有了一个贴心的"管家"来帮我们处理所有繁琐的事情。