Rust语言之GoF设计模式：外观Facade模式

22-09-26 banq

Facade（外观、总管）是一种结构设计模式，它为复杂的类、库或框架系统提供了一个简化的（但有限的）接口。

API其实是一种Facade模式的实现，在API背后隐藏了一个复杂的逻辑。
Facade模式类似于组合模式，都是将复杂或繁杂Complicated的细节隐藏起来，提供一个干净的外观门面，如同一个美女看起来很漂亮干净，但是家里东西却乱七八糟一样。

例如：wallet_facade.rs 提供了一个方法add_money_to_wallet，但是在其后隐藏了与账户、代码、钱包、通知和分类账进行交互。

use crate::{
    account::Account, ledger::Ledger, notification::Notification, security_code::SecurityCode,
    wallet::Wallet,
};

/// Facade hides a complex logic behind the API.
pub struct WalletFacade {
    account: Account,
    wallet: Wallet,
    code: SecurityCode,
    notification: Notification,
    ledger: Ledger,
}

impl WalletFacade {
    pub fn new(account_id: String, code: u32) -> Self {
        println!("Starting create account");

        let this = Self {
            account: Account::new(account_id),
            wallet: Wallet::new(),
            code: SecurityCode::new(code),
            notification: Notification,
            ledger: Ledger,
        };

        println!("Account created");
        this
    }

    pub fn add_money_to_wallet(
        &mut self,
        account_id: &String,
        security_code: u32,
        amount: u32,
    ) -> Result<(), String> {
        println!("Starting add money to wallet");
        self.account.check(account_id)?;
        self.code.check(security_code)?;
        self.wallet.credit_balance(amount);
        self.notification.send_wallet_credit_notification();
        self.ledger.make_entry(account_id, "credit".into(), amount);
        Ok(())
    }

    pub fn deduct_money_from_wallet(
        &mut self,
        account_id: &String,
        security_code: u32,
        amount: u32,
    ) -> Result<(), String> {
        println!("Starting debit money from wallet");
        self.account.check(account_id)?;
        self.code.check(security_code)?;
        self.wallet.debit_balance(amount);
        self.notification.send_wallet_debit_notification();
        self.ledger.make_entry(account_id, "debit".into(), amount);
        Ok(())
    }
}

Rust模块重导出
Rust语言中通过模块 Re-Export实现门面模式：
模块 Re-Export 是重导出功能。
比如，现在有如下模块层级：

#![allow(unused)]
fn main() {
src/
    - lib.rs
    - module/
        -- mod.rs
        -- submodule/
            --- mod.rs
}

Rust 能让最深处的那个模块 submodule 里定义的函数，使用重导出功能，变成整个库的「门面」接口。

#![allow(unused)]
fn main() {
// in module/submodule/mod.rs
pub fn goodbye(){}

// in lib.rs
pub use module::submodule::goodbye;

那么在使用这个库（假设叫 hello）的时候，只需要使用 hello::goodby就可以使用这个函数。
这种方式在 Rust 的世界大量使用。比如标准库很多接口是重导出了核心库的 API。

Rust条件编译
条件编译也是一种门面模式。
比如在 TiKV 中，使用条件编译和 features 来支持多种内存分配器。

#![allow(unused)]
fn main() {
 #[cfg(all(unix, not(fuzzing), feature = "jemalloc"))]
 #[path = "jemalloc.rs"]
 mod imp;

 #[cfg(all(unix, not(fuzzing), feature = "tcmalloc"))]
 #[path = "tcmalloc.rs"]
 mod imp;

 #[cfg(all(unix, not(fuzzing), feature = "mimalloc"))]
 #[path = "mimalloc.rs"]
 mod imp;

 #[cfg(not(all(
    unix,
    not(fuzzing),
    any(feature = "jemalloc", feature = "tcmalloc", feature = "mimalloc")
 )))]
 #[path = "system.rs"]
 mod imp;
}

实际上并不存在 imp 模块，通过不同的 cfg 判断，对应不同的 path，从而选择相应的模块：jemalloc.rs/tcmalloc.rs/mimalloc.rs/system.rs。而 imp 模块就是一个「门面」。

利用类型和 Trait实现门面
第三种方式，就是常规的利用类型和 trait 来实现门面模型。
这种方式类似Java中实现统一接口，或统一API做法。