外观模式

+-------------------------------------------------------------+
|                     外观模式结构                             |
+-------------------------------------------------------------+
|                                                             |
|   +-------------+                  +-------------+          |
|   |   Client    |                  |   Facade    |          |
|   |   客户端    | ---------------> |   外观      |          |
|   +-------------+                  +-------------+          |
|                                          |                  |
|                           +--------------+--------------+   |
|                           |              |              |   |
|                           v              v              v   |
|                    +-----------+  +-----------+  +-----------+
|                    |SubsystemA |  |SubsystemB |  |SubsystemC |
|                    | 子系统A   |  | 子系统B   |  | 子系统C   |
|                    +-----------+  +-----------+  +-----------+
|                                                             |
|   Facade 聚合所有子系统，对外提供简化接口                    |
+-------------------------------------------------------------+

+-------------------------------------------------------------+
|                   外观模式与设计原则                         |
+-------------------------------------------------------------+
|                                                             |
|  +-----------------------------------------------------+   |
|  | 迪米特法则 (LoD / 最少知识原则)                       |   |
|  | -- 客户端只与外观交互，不直接与子系统交互             |   |
|  | -- 减少对象之间的耦合，降低通信复杂度                 |   |
|  +-----------------------------------------------------+   |
|                                                             |
|  +-----------------------------------------------------+   |
|  | 单一职责原则 (SRP)                                   |   |
|  | -- 外观只负责接口简化与委派，不处理具体业务          |   |
|  | -- 子系统各自负责自己的功能                          |   |
|  +-----------------------------------------------------+   |
|                                                             |
|  +-----------------------------------------------------+   |
|  | 开闭原则 (OCP)                                       |   |
|  | -- 新增子系统时可以扩展外观，无需修改客户端          |   |
|  | -- 子系统内部变化不影响外观接口                      |   |
|  +-----------------------------------------------------+   |
|                                                             |
+-------------------------------------------------------------+

+-------------------------------------------------------------+
|                 如何判断是否使用外观模式？                    |
+-------------------------------------------------------------+
|                                                             |
|  子系统接口复杂，客户端使用困难？                            |
|       |                                                     |
|       +-- 是 --> 使用外观模式简化接口                        |
|       |                                                     |
|       +-- 否 --> 需要对子系统进行分层访问控制？              |
|                     |                                       |
|                     +-- 是 --> 使用外观模式作为层间入口      |
|                     |                                       |
|                     +-- 否 --> 需要封装遗留系统？            |
|                           |                                 |
|                           +-- 是 --> 使用外观模式封装旧接口  |
|                           |                                 |
|                           +-- 否 --> 考虑其他模式            |
|                                                             |
+-------------------------------------------------------------+

+-------------------------------------------------------------+
|                     角色交互关系                             |
+-------------------------------------------------------------+
|                                                             |
|  Client                                                     |
|    |                                                        |
|    | 调用简化接口                                           |
|    v                                                        |
|  Facade                                                     |
|    |                                                        |
|    +-- 委派 --> SubsystemA.operationA1()                    |
|    +-- 委派 --> SubsystemB.operationB1()                    |
|    +-- 委派 --> SubsystemC.operationC1()                    |
|    |                                                        |
|    | 整合结果并返回                                         |
|    v                                                        |
|  Client <-- 统一响应                                        |
|                                                             |
|  关键特征：                                                 |
|  1. 子系统不知道 Facade 的存在                              |
|  2. 客户端不知道子系统的存在                                |
|  3. Facade 是单向依赖，不形成循环引用                       |
|                                                             |
+-------------------------------------------------------------+

+-------------------------------------------------------------+
|                   是否需要使用外观模式？                      |
+-------------------------------------------------------------+
|                                                             |
|  +-----------------------------------------------------+   |
|  | 适合使用外观模式                                     |   |
|  +-----------------------------------------------------+   |
|  | -- 子系统接口复杂，客户端使用困难                    |   |
|  | -- 需要对子系统进行分层访问控制                      |   |
|  | -- 需要封装遗留系统，提供现代化接口                  |   |
|  | -- 多个客户端共享相同的子系统调用序列                |   |
|  | -- 需要减少客户端与子系统之间的依赖                  |   |
|  +-----------------------------------------------------+   |
|                                                             |
|  +-----------------------------------------------------+   |
|  | 不适合使用外观模式                                   |   |
|  +-----------------------------------------------------+   |
|  | -- 子系统接口已经足够简单                            |   |
|  | -- 客户端需要直接访问子系统的特定功能                |   |
|  | -- 子系统之间没有关联，无需统一入口                  |   |
|  | -- 过度封装会隐藏必要的灵活性                        |   |
|  +-----------------------------------------------------+   |
|                                                             |
+-------------------------------------------------------------+

// ==================== 子系统定义 ====================

/** 灯光子系统 */
class LightSystem {
  private brightness: number = 0;
  private color: string = 'white';

  turnOn(): void {
    this.brightness = 100;
    console.log('[LightSystem] 灯光已开启，亮度: 100%');
  }
  turnOff(): void {
    this.brightness = 0;
    console.log('[LightSystem] 灯光已关闭');
  }
  setBrightness(v: number): void { this.brightness = v; }
  setColor(c: string): void { this.color = c; }
  getStatus() { return { brightness: this.brightness, color: this.color }; }
}

/** 空调子系统 */
class AirConditioner {
  private temperature: number = 26;
  private power: boolean = false;
  turnOn(): void { this.power = true; console.log('[AC] 空调已开启，26℃'); }
  turnOff(): void { this.power = false; console.log('[AC] 空调已关闭'); }
  setTemperature(t: number): void { this.temperature = t; }
  getStatus() { return { power: this.power, temperature: this.temperature }; }
}

/** 窗帘子系统 */
class CurtainSystem {
  private openPercent: number = 0;
  open(percent = 100): void { this.openPercent = percent; console.log(`[Curtain] 窗帘打开至 ${percent}%`); }
  close(): void { this.openPercent = 0; console.log('[Curtain] 窗帘关闭'); }
  getStatus() { return { openPercent: this.openPercent }; }
}

/** 音乐子系统 */
class MusicSystem {
  private playing = false;
  play(playlist: string): void { this.playing = true; console.log(`[Music] 播放: ${playlist}`); }
  stop(): void { this.playing = false; console.log('[Music] 停止播放'); }
  getStatus() { return { playing: this.playing }; }
}

// ==================== 外观 ====================
class SmartHomeFacade {
  private light = new LightSystem();
  private ac = new AirConditioner();
  private curtain = new CurtainSystem();
  private music = new MusicSystem();

  homeMode(): void {
    console.log('--- 回家模式 ---');
    this.light.turnOn();
    this.ac.turnOn();
    this.curtain.open(80);
    this.music.play('轻音乐');
  }
  awayMode(): void {
    console.log('--- 离家模式 ---');
    this.light.turnOff();
    this.ac.turnOff();
    this.curtain.close();
    this.music.stop();
  }
  getAllStatus(): Record<string, unknown> {
    return { light: this.light.getStatus(), ac: this.ac.getStatus(), curtain: this.curtain.getStatus(), music: this.music.getStatus() };
  }
}

// ==================== 使用 ====================
const smartHome = new SmartHomeFacade();
smartHome.homeMode();

// 一键离家
smartHome.awayMode();

// 查看状态
console.log(smartHome.getAllStatus());

/** 子系统接口约束 */
interface ISubsystem {
  init(): void;
  destroy(): void;
  getStatus(): Record<string, unknown>;
}

/** 泛型外观：支持任意子系统组合 */
class Facade<TSubsystems extends Record<string, ISubsystem>> {
  private subsystems: TSubsystems;
  private initialized: boolean = false;

  constructor(subsystems: TSubsystems) {
    this.subsystems = subsystems;
  }

  init(): void {
    Object.values(this.subsystems).forEach((s) => s.init());
    this.initialized = true;
  }
  destroy(): void {
    Object.values(this.subsystems).forEach((s) => s.destroy());
    this.initialized = false;
  }
  getStatus(): Record<string, unknown> {
    const status: Record<string, unknown> = {};
    Object.entries(this.subsystems).forEach(([name, s]) => { status[name] = s.getStatus(); });
    return status;
  }
  // 批量执行命令
  execute(commands: Array<{ subsystem: keyof TSubsystems; method: string; args: unknown[] }>): void {
    commands.forEach((cmd) => {
      const target = this.subsystems[cmd.subsystem] as unknown as Record<string, Function>;
      target[cmd.method]?.(...cmd.args);
    });
  }
}

// ==================== 使用 ====================
const appFacade = new Facade({
  database: dbSubsystem,
  cache: cacheSubsystem,
  logger: loggerSubsystem,
});
appFacade.init();

// 批量操作
appFacade.execute([
  { subsystem: 'database', method: 'query', args: ['SELECT 1'] },
  { subsystem: 'cache', method: 'set', args: ['key', 'value'] },
  { subsystem: 'logger', method: 'info', args: ['系统启动'] },
]);

/** 子系统工厂类型 */
type SubsystemFactory<T> = () => T;

/** 懒加载外观：子系统在首次使用时才创建 */
class LazyFacade<TSubsystems extends Record<string, () => ISubsystem>> {
  private factories: TSubsystems;
  private instances: Map<string, ISubsystem> = new Map();

  constructor(factories: TSubsystems) {
    this.factories = factories;
  }

  // 首次访问时才创建子系统
  get<K extends keyof TSubsystems>(name: K): ISubsystem {
    const key = name as string;
    if (!this.instances.has(key)) {
      const factory = this.factories[name];
      const instance = factory();
      console.log(`[Lazy] 首次创建子系统: ${key}`);
      this.instances.set(key, instance);
    }
    return this.instances.get(key)!;
  }

  preload(names: Array<keyof TSubsystems>): void {
    names.forEach((name) => this.get(name));
  }
  getLoadedNames(): string[] {
    return [...this.instances.keys()];
  }
}

// ==================== 使用 ====================
const lazyApp = new LazyFacade({
  database: () => dbSubsystem,   // 仅声明，不立即创建
  cache: () => cacheSubsystem,
  logger: () => loggerSubsystem,
});

lazyApp.get('database');
// [Database] 初始化连接池

console.log('已加载:', lazyApp.getLoadedNames()); // ['database']

// 预加载多个子系统
lazyApp.preload(['cache', 'logger']);

type EventCallback = (...args: unknown[]) => void;

/** 事件发射器 -- 外观基类 */
class EventEmitterFacade {
  private events: Map<string, Set<EventCallback>> = new Map();

  on(event: string, callback: EventCallback): () => void {
    if (!this.events.has(event)) {
      this.events.set(event, new Set());
    }
    this.events.get(event)!.add(callback);
    return () => this.off(event, callback);
  }

  off(event: string, callback: EventCallback): void {
    this.events.get(event)?.delete(callback);
  }

  protected emit(event: string, ...args: unknown[]): void {
    this.events.get(event)?.forEach((cb) => cb(...args));
  }
}

// ==================== 事件驱动的智能家居外观 ====================
class SmartHomeEventFacade extends EventEmitterFacade {
  homeMode(): void {
    this.emit('mode:before', 'home');
    console.log('... 各子系统操作 ...');
    this.emit('mode:after', 'home');
  }
}

// ==================== 使用 ====================
const eventHome = new SmartHomeEventFacade();
eventHome.on('mode:before', (mode) => console.log(`模式即将切换: unknown -> ${mode}`));
eventHome.on('mode:after', (mode) => console.log(`模式已切换为: ${mode}`));

// 触发模式切换
eventHome.homeMode();
// 模式即将切换: unknown -> home
// ... 各子系统操作 ...
// 模式已切换为: home

/** 场景配置接口 */
interface SceneConfig {
  lightOn: boolean;
  lightBrightness: number;
  lightColor: string;
  acOn: boolean;
  acTemperature: number;
  acMode: 'cool' | 'heat' | 'auto';
  curtainOpen: boolean;
  curtainPercent: number;
  musicOn: boolean;
  musicPlaylist: string;
}

// ==================== 可配置场景外观 ====================
interface HomeScene {
  name: string;
  config: SceneConfig;
}

class ConfigurableHomeFacade {
  private scenes = new Map<string, SceneConfig>();

  registerScene(name: string, config: SceneConfig): this {
    this.scenes.set(name, config);
    return this;
  }

  applyScene(name: string): void {
    const config = this.scenes.get(name);
    if (!config) throw new Error(`未注册场景: ${name}`);
    console.log(`--- 应用场景: ${name} ---`);
    if (config.lightOn) console.log(`开灯，亮度 ${config.lightBrightness}，颜色 ${config.lightColor}`);
    if (config.acOn) console.log(`开空调，${config.acTemperature}℃，模式 ${config.acMode}`);
    if (config.curtainOpen) console.log(`开窗帘，打开 ${config.curtainPercent}%`);
    if (config.musicOn) console.log(`播放音乐：${config.musicPlaylist}`);
  }
}

// ==================== 场景构建器（结合 Builder 模式） ====================
class SceneConfigBuilder {
  private config: SceneConfig = {
    lightOn: false, lightBrightness: 100, lightColor: 'white',
    acOn: false, acTemperature: 26, acMode: 'auto',
    curtainOpen: false, curtainPercent: 100,
    musicOn: false, musicPlaylist: '',
  };
  light(brightness: number, color: string): this { this.config.lightOn = true; this.config.lightBrightness = brightness; this.config.lightColor = color; return this; }
  ac(temp: number, mode: SceneConfig['acMode']): this { this.config.acOn = true; this.config.acTemperature = temp; this.config.acMode = mode; return this; }
  curtain(percent: number): this { this.config.curtainOpen = true; this.config.curtainPercent = percent; return this; }
  music(playlist: string): this { this.config.musicOn = true; this.config.musicPlaylist = playlist; return this; }
  build(): SceneConfig { return { ...this.config }; }
}

// ==================== 使用 ====================
const home = new ConfigurableHomeFacade();
home.registerScene('reading', new SceneConfigBuilder()
  .light(50, 'warm')
  .ac(24, 'cool')
  .build(),
);
home.registerScene('gaming', new SceneConfigBuilder()
  .light(80, 'blue')
  .ac(22, 'cool')
  .music('游戏BGM')
  .build(),
);

// 一键应用场景
home.applyScene('reading');
home.applyScene('gaming');

/** 文件处理子系统群 */
class SourceFileReader {
  read(path: string): string {
    console.log(`[SourceFileReader] 读取文件: ${path}`);
    return 'file content';
  }
}

class FileParser {
  parse(buffer: string, format: string): Record<string, unknown> {
    console.log(`[FileParser] 解析格式: ${format}`);
    return { data: buffer };
  }
}

class FileValidator {
  validate(buffer: string): boolean {
    console.log('[FileValidator] 校验文件完整性');
    return buffer.length > 0;
  }
}

// ==================== 文件处理外观 ====================
class FileProcessingFacade {
  private reader = new SourceFileReader();
  private parser = new FileParser();
  private validator = new FileValidator();

  processFile(path: string): Record<string, unknown> {
    const buffer = this.reader.read(path);
    if (!this.validator.validate(buffer)) {
      throw new Error(`文件校验失败: ${path}`);
    }
    const format = path.split('.').pop() ?? 'json';
    return this.parser.parse(buffer, format);
  }
}

// 客户端只需一行代码
const fileFacade = new FileProcessingFacade();
const result = fileFacade.processFile('/data/config.json');

/** 遗留系统 -- 接口混乱、命名不规范 */
class LegacyUserSystem {
  usr_get(id: number): { usr_name: string; usr_age: number; usr_email: string } {
    return { usr_name: 'Alice', usr_age: 25, usr_email: 'alice@test.com' };
  }

  usr_upd(id: number, data: Record<string, unknown>): boolean {
    console.log('[Legacy] 更新用户', id, data);
    return true;
  }

  usr_del(id: number): boolean {
    console.log('[Legacy] 删除用户', id);
    return true;
  }

  usr_orders(id: number): Array<{ id: number; amount: number }> {
    return [{ id: 1, amount: 99.9 }];
  }
}

// ==================== 现代化外观 ====================
class ModernAPIFacade {
  private legacy = new LegacyUserSystem();

  getUser(id: number): { name: string; age: number; email: string } {
    const u = this.legacy.usr_get(id);
    return { name: u.usr_name, age: u.usr_age, email: u.usr_email };
  }
  updateUser(id: number, data: { name?: string; age?: number }): boolean {
    return this.legacy.usr_upd(id, data);
  }
  deleteUser(id: number): boolean {
    return this.legacy.usr_del(id);
  }
  getUserOrders(id: number): Array<{ id: number; amount: number }> {
    return this.legacy.usr_orders(id);
  }
}

// 客户端使用现代化接口
const api = new ModernAPIFacade();
const user = api.getUser(1); // { name: 'Alice', age: 25, email: 'alice@test.com' }
const orders = api.getUserOrders(1); // [{ id: 1, amount: 99.9 }]

import axios from 'axios';
import type {
  AxiosInstance,
  AxiosRequestConfig,
  AxiosResponse,
  InternalAxiosRequestConfig,
} from 'axios';

/** 请求配置扩展 */
interface RequestConfig extends AxiosRequestConfig {
  /** 是否跳过错误提示 */
  skipErrorHandler?: boolean;
  /** 是否跳过认证 */
  skipAuth?: boolean;
}

/** Axios 外观封装：统一请求/响应处理 */
class HttpClient {
  private instance: AxiosInstance;

  constructor() {
    this.instance = axios.create({ baseURL: '/api', timeout: 10000 });
    this.setupInterceptors();
  }

  private setupInterceptors(): void {
    // 请求拦截：注入 token
    this.instance.interceptors.request.use((config: InternalAxiosRequestConfig) => {
      if (!(config as RequestConfig).skipAuth) {
        config.headers.Authorization = `Bearer ${getToken()}`;
      }
      return config;
    });
    // 响应拦截：统一错误处理
    this.instance.interceptors.response.use(
      (res) => res,
      (error) => {
        if (error.response?.status === 401) { redirectToLogin(); }
        if (!error.config?.skipErrorHandler) { showErrorMessage(error.message); }
        return Promise.reject(error);
      }
    );
  }

  async get<T>(url: string, config?: RequestConfig): Promise<T> {
    const res = await this.instance.get<AxiosResponse<T>>(url, config);
    return (res as unknown as AxiosResponse<T>).data;
  }
  async post<T>(url: string, data?: unknown, config?: RequestConfig): Promise<T> {
    const res = await this.instance.post<AxiosResponse<T>>(url, data, config);
    return (res as unknown as AxiosResponse<T>).data;
  }
}

const http = new HttpClient();

// ==================== 使用 ====================
interface User { id: number; name: string; }

const user = await http.get<User>('/users/1');
await http.post<User>('/users', { name: 'Bob' });

/** 微服务接口定义 */
interface UserService {
  getUser(id: string): Promise<{ id: string; name: string; email: string }>;
  updateUser(id: string, data: Partial<{ name: string; email: string }>): Promise<boolean>;
}

interface OrderService {
  getOrders(userId: string): Promise<Array<{ id: string; amount: number; status: string }>>;
  createOrder(userId: string, items: Array<{ productId: string; quantity: number }>): Promise<string>;
}

interface PaymentService {
  pay(amount: number, method: string): Promise<string>;
  refund(transactionId: string): Promise<boolean>;
}

// ==================== API Gateway 外观 ====================
class APIGateway {
  private userService: UserService;
  private orderService: OrderService;
  private paymentService: PaymentService;

  constructor() {
    this.userService = createUserServiceClient();
    this.orderService = createOrderServiceClient();
    this.paymentService = createPaymentServiceClient();
  }

  /** 获取用户及其订单 -- 跨服务聚合 */
  async getUserDashboard(userId: string): Promise<{ user: { id: string; name: string }; orders: Array<{ id: string; amount: number }> }> {
    const [user, orders] = await Promise.all([
      this.userService.getUser(userId),
      this.orderService.getOrders(userId),
    ]);
    return { user, orders };
  }

  /** 下单并支付 -- 跨服务操作 */
  async placeOrder(userId: string, items: Array<{ productId: string; quantity: number }>, paymentMethod: string): Promise<string> {
    const orderId = await this.orderService.createOrder(userId, items);
    await this.paymentService.pay(99.9, paymentMethod);
    return orderId;
  }

  /** 退款 -- 跨服务操作 */
  async refundOrder(transactionId: string): Promise<boolean> {
    return this.paymentService.refund(transactionId);
  }
}

/** 微信 JSSDK 风格的统一入口外观 */
class WeChatSDKFacade {
  private configReady: boolean = false;

  /** 初始化配置 */
  config(options: {
    appId: string;
    timestamp: number;
    nonceStr: string;
    signature: string;
  }): void {
    console.log('[WeChatSDK] 配置初始化', options.appId);
    this.configReady = true;
  }

  /** 分享到朋友圈 */
  shareToTimeline(options: { title: string; link: string; imgUrl: string }): void {
    if (!this.configReady) throw new Error('请先调用 config');
    console.log('[WeChatSDK] 分享到朋友圈:', options.title);
  }

  /** 分享给朋友 */
  shareToFriend(options: { title: string; desc: string; link: string; imgUrl: string }): void {
    if (!this.configReady) throw new Error('请先调用 config');
    console.log('[WeChatSDK] 分享给朋友:', options.title);
  }

  /** 扫一扫 */
  async scanQRCode(): Promise<string> {
    if (!this.configReady) throw new Error('请先调用 config');
    console.log('[WeChatSDK] 打开扫一扫');
    return 'QRCode-Result';
  }
}

// 客户端使用 -- 统一入口 wx.xxx()
const wx = new WeChatSDKFacade();
wx.config({ appId: 'xxx', timestamp: 123, nonceStr: 'abc', signature: 'sig' });
wx.shareToFriend({ title: 'Hello', desc: 'World', link: 'https://example.com', imgUrl: '' });
const code = await wx.scanQRCode();

/** 简化版 jQuery 风格外观 -- 展示外观模式思想 */
class DOMFacade {
  private elements: Element[];

  constructor(selector: string | Element) {
    if (typeof selector === 'string') {
      this.elements = Array.from(document.querySelectorAll(selector));
    } else {
      this.elements = [selector];
    }
  }

  addClass(className: string): this {
    this.elements.forEach((el) => el.classList.add(className));
    return this;
  }
  removeClass(className: string): this {
    this.elements.forEach((el) => el.classList.remove(className));
    return this;
  }
  css(property: string, value: string): this {
    this.elements.forEach((el) => (el as HTMLElement).style.setProperty(property, value));
    return this;
  }
  on(event: string, handler: (e: Event) => void): this {
    this.elements.forEach((el) => el.addEventListener(event, handler));
    return this;
  }
  fadeIn(duration: number): this {
    this.elements.forEach((el) => {
      const target = el as HTMLElement;
      target.style.opacity = '0';
      target.style.transition = `opacity ${duration}ms`;
      requestAnimationFrame(() => { target.style.opacity = '1'; });
    });
    return this;
  }
  html(content: string): this {
    this.elements.forEach((el) => { el.innerHTML = content; });
    return this;
  }
}

// 全局 $ 函数（外观入口）
function $(selector: string | Element): DOMFacade {
  return new DOMFacade(selector);
}

// 客户端使用 -- 链式调用，极简 API
$('.btn')
  .addClass('active')
  .css('color', 'red')
  .on('click', () => console.log('clicked'))
  .fadeIn(300);

// ========== 外观模式 ==========
// 简化多个子系统的调用
class SmartHomeFacade {
  private light = new LightSystem();
  private ac = new AirConditioner();

  homeMode(): void {
    this.light.turnOn();  // 委派子系统
    this.ac.turnOn();     // 委派子系统
  }
}

// ========== 代理模式 ==========
// 控制访问，接口不变
class LightSystemProxy {
  private real = new LightSystem();
  homeMode(): void {
    if (this.hasPermission()) {
      this.real.turnOn(); // 权限控制
    }
  }
  private hasPermission(): boolean { return true; }
}

// ========== 适配器模式 ==========
// 转换接口，使不兼容的接口可用
interface ILogger {
  log(msg: string): void;
}
class LegacyLogger {
  writeLog(msg: string): void { console.log(msg); }
}
class LoggerAdapter implements ILogger {
  constructor(private legacy: LegacyLogger) {}

  log(msg: string): void {
    this.legacy.writeLog(msg); // 接口转换
  }
}

/** 外观 + 单例 + 工厂 组合示例 */
class ApplicationFacade {
  private static instance: ApplicationFacade;
  private subsystems: Map<string, ISubsystem> = new Map();

  private constructor() {}

  static getInstance(): ApplicationFacade {
    if (!ApplicationFacade.instance) {
      ApplicationFacade.instance = new ApplicationFacade();
    }
    return ApplicationFacade.instance;
  }

  /** 使用工厂创建子系统 */
  registerSubsystem(name: string, factory: () => ISubsystem): void {
    this.subsystems.set(name, factory());
  }

  /** 统一初始化 */
  async init(): Promise<void> {
    for (const sub of this.subsystems.values()) {
      sub.init();
    }
  }
}

// 子系统：复杂的多个组件
class CPU {
    public void boot() { System.out.println("CPU 启动"); }
    public void shutdown() { System.out.println("CPU 关闭"); }
}

class Memory {
    public void load() { System.out.println("内存加载"); }
    public void release() { System.out.println("内存释放"); }
}

class HardDrive {
    public void read() { System.out.println("硬盘读取"); }
    public void stop() { System.out.println("硬盘停止"); }
}

// 外观：为子系统提供简化统一接口，客户端只依赖外观
class ComputerFacade {
    private final CPU cpu = new CPU();
    private final Memory memory = new Memory();
    private final HardDrive hardDrive = new HardDrive();

    public void start() {
        cpu.boot();
        memory.load();
        hardDrive.read();
    }

    public void shutdown() {
        hardDrive.stop();
        memory.release();
        cpu.shutdown();
    }
}

// 使用：客户端无需了解子系统细节
public class Client {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.start();     // 统一开机流程
        computer.shutdown();  // 统一关机流程
    }
}

# 子系统
class CPU:
    def boot(self):
        print("CPU 启动")

    def shutdown(self):
        print("CPU 关闭")

class Memory:
    def load(self):
        print("内存加载")

    def release(self):
        print("内存释放")

class HardDrive:
    def read(self):
        print("硬盘读取")

    def stop(self):
        print("硬盘停止")

# 外观
class ComputerFacade:
    def __init__(self):
        self._cpu = CPU()
        self._memory = Memory()
        self._hard_drive = HardDrive()

    def start(self):
        self._cpu.boot()
        self._memory.load()
        self._hard_drive.read()

    def shutdown(self):
        self._hard_drive.stop()
        self._memory.release()
        self._cpu.shutdown()

# 使用
computer = ComputerFacade()
computer.start()
computer.shutdown()