Rust 设计模式

简介

设计模式是软件工程中的一个概念，用于解决特定问题的通用模板。它们提供了一种经过验证的方法来组织代码结构和处理常见的编程问题。Rust 是一种系统级编程语言，以其内存安全、并发性以及零成本抽象而闻名。本章将探讨如何在 Rust 中应用一些常见的设计模式。

单例模式

什么是单例模式？

单例模式确保一个类只有一个实例，并提供一个全局访问点。

如何在 Rust 中实现单例模式？

使用静态变量

pub struct Singleton;

impl Singleton {
    pub fn get_instance() -> &'static Self {
        static INSTANCE: Singleton = Singleton;
        &INSTANCE
    }
}

使用懒加载（Lazy Initialization）

// www.javascriptcn.com code example
use std::sync::OnceLock;

pub struct Singleton;

impl Singleton {
    pub fn get_instance() -> &'static Self {
        static INSTANCE: OnceLock<Singleton> = OnceLock::new();
        INSTANCE.get_or_init(|| Singleton)
    }
}

示例代码

fn main() {
    let instance_1 = Singleton::get_instance();
    let instance_2 = Singleton::get_instance();

    assert!(std::ptr::eq(instance_1, instance_2));
}

工厂模式

什么是工厂模式？

工厂模式是一种创建型设计模式，它提供了创建对象的最佳方式。当一个类不知道它所必须创建的对象的类时，或者当一个类希望它的子类决定要创建的对象时，使用工厂方法模式。

如何在 Rust 中实现工厂模式？

定义产品接口

trait Product {
    fn use_product(&self);
}

创建具体产品类

// www.javascriptcn.com code example
struct ConcreteProductA;

impl Product for ConcreteProductA {
    fn use_product(&self) {
        println!("Using ConcreteProductA");
    }
}

struct ConcreteProductB;

impl Product for ConcreteProductB {
    fn use_product(&self) {
        println!("Using ConcreteProductB");
    }
}

定义工厂接口

trait Factory {
    fn create_product(&self) -> Box<dyn Product>;
}

实现工厂类

// www.javascriptcn.com code example
struct ConcreteFactoryA;

impl Factory for ConcreteFactoryA {
    fn create_product(&self) -> Box<dyn Product> {
        Box::new(ConcreteProductA)
    }
}

struct ConcreteFactoryB;

impl Factory for ConcreteFactoryB {
    fn create_product(&self) -> Box<dyn Product> {
        Box::new(ConcreteProductB)
    }
}

示例代码

// www.javascriptcn.com code example
fn main() {
    let factory_a = ConcreteFactoryA;
    let product_a = factory_a.create_product();
    product_a.use_product();

    let factory_b = ConcreteFactoryB;
    let product_b = factory_b.create_product();
    product_b.use_product();
}

观察者模式

什么是观察者模式？

观察者模式是一种行为设计模式，它允许你定义一个订阅机制，可以在对象事件发生时通知多个“观察”该对象的其他对象。

如何在 Rust 中实现观察者模式？

定义观察者接口

trait Observer {
    fn update(&self, message: &str);
}

创建被观察者类

// www.javascriptcn.com code example
struct Subject {
    observers: Vec<Box<dyn Observer>>,
    state: String,
}

impl Subject {
    pub fn new(state: String) -> Self {
        Subject { observers: vec![], state }
    }

    pub fn attach(&mut self, observer: Box<dyn Observer>) {
        self.observers.push(observer);
    }

    pub fn notify(&self) {
        for observer in self.observers.iter() {
            observer.update(&self.state);
        }
    }

    pub fn set_state(&mut self, state: String) {
        self.state = state;
        self.notify();
    }
}

创建观察者类

// www.javascriptcn.com code example
struct ConcreteObserverA;

impl Observer for ConcreteObserverA {
    fn update(&self, message: &str) {
        println!("ConcreteObserverA received: {}", message);
    }
}

struct ConcreteObserverB;

impl Observer for ConcreteObserverB {
    fn update(&self, message: &str) {
        println!("ConcreteObserverB received: {}", message);
    }
}

示例代码

// www.javascriptcn.com code example
fn main() {
    let mut subject = Subject::new(String::from("Initial State"));

    let observer_a = Box::new(ConcreteObserverA);
    let observer_b = Box::new(ConcreteObserverB);

    subject.attach(observer_a);
    subject.attach(observer_b);

    subject.set_state(String::from("New State"));
}

结语

本章介绍了 Rust 中的一些常见设计模式，包括单例模式、工厂模式和观察者模式。通过这些示例，你可以更好地理解如何在实际项目中应用这些模式。下一章我们将探讨更多的设计模式及其在 Rust 中的应用。