高级设计模式

发布时间：2025年1月6日

RAII 模式

资源获取即初始化（RAII）是 Rust 中的核心模式。

RAII 模式示例 
pub struct Server {
    host: String,
    port: u16,
    workers: u32,
}

pub struct ServerBuilder {
    host: Option,
    port: Option,
    workers: Option,
}

impl ServerBuilder {
    pub fn new() -> ServerBuilder {
        ServerBuilder {
            host: None,
            port: None,
            workers: None,
        }
    }
    
    pub fn host(mut self, host: String) -> ServerBuilder {
        self.host = Some(host);
        self
    }
    
    pub fn build(self) -> Result {
        Ok(Server {
            host: self.host.ok_or("host is required")?,
            port: self.port.unwrap_or(8080),
            workers: self.workers.unwrap_or(4),
        })
    }
}

构建者模式

构建者模式是一种设计模式，它使得我们可以一步一步地构造复杂的对象。

构建者模式示例 
pub struct Server {
    host: String,
    port: u16,
    workers: u32,
}

pub struct ServerBuilder {
    host: Option,
    port: Option,
    workers: Option,
}

impl ServerBuilder {
    pub fn new() -> ServerBuilder {
        ServerBuilder {
            host: None,
            port: None,
            workers: None,
        }
    }
    
    pub fn host(mut self, host: String) -> ServerBuilder {
        self.host = Some(host);
        self
    }
    
    pub fn build(self) -> Result {
        Ok(Server {
            host: self.host.ok_or("host is required")?,
            port: self.port.unwrap_or(8080),
            workers: self.workers.unwrap_or(4),
        })
    }
}

访问者模式

访问者模式是一种设计模式，它使得我们可以对一个对象结构中的元素进行操作，而不需要修改该结构。

访问者模式示例 
trait Visitor {
    fn visit_num(&mut self, n: &Number);
    fn visit_add(&mut self, a: &Add);
}

enum Expr {
    Number(Number),
    Add(Add),
}

impl Expr {
    fn accept(&self, visitor: &mut dyn Visitor) {
        match self {
            Expr::Number(n) => visitor.visit_num(n),
            Expr::Add(a) => visitor.visit_add(a),
        }
    }
}

状态模式

状态模式是一种设计模式，它使得我们可以根据状态来改变一个对象的行为。

状态模式示例 
trait State {
    fn request_review(self: Box) -> Box;
    fn approve(self: Box) -> Box;
    fn content<'a>(&self, post: &'a Post) -> &'a str;
}

pub struct Post {
    state: Option>,
    content: String,
}

impl Post {
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }
    
    pub fn request_review(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.request_review())
        }
    }
}

命令模式

命令模式是一种设计模式，它使得我们可以将一个请求封装成一个对象，从而可以使用不同的请求、队列或日志来参数化其他对象。

命令模式示例 
trait Command {
    fn execute(&self) -> Result<(), String>;
    fn undo(&self) -> Result<(), String>;
}

struct InsertTextCommand {
    document: Rc>,
    position: usize,
    text: String,
}

impl Command for InsertTextCommand {
    fn execute(&self) -> Result<(), String> {
        self.document.borrow_mut().insert(
            self.position,
            &self.text
        )
    }
}

高级模式匹配

Rust 的模式匹配功能非常强大，可以处理复杂的数据结构：

复杂模式匹配示例 
enum Message {
    Hello { id: i32 },
    Move { x: i32, y: i32 },
    Write(String),
}

fn process_message(msg: Message) {
    match msg {
        Message::Hello { id: id_variable @ 3..=7 } => {
            println!("Found id in range: {}", id_variable)
        }
        Message::Hello { id: 10 } => {
            println!("Found id 10")
        }
        Message::Move { x, y } if x < 0 && y < 0 => {
            println!("Move to negative space")
        }
        Message::Write(text) => println!("{}", text),
        _ => println!("No match found"),
    }
}

高级特征

Rust 提供了一些高级特征功能：

关联类型示例 
trait Container {
    type Item;
    fn get(&self) -> Option<&Self::Item>;
    fn insert(&mut self, item: Self::Item);
}

struct Stack {
    items: Vec,
}

impl Container for Stack {
    type Item = T;
    
    fn get(&self) -> Option<&Self::Item> {
        self.items.last()
    }
    
    fn insert(&mut self, item: Self::Item) {
        self.items.push(item)
    }
}

宏编程

Rust 的宏系统允许我们进行元编程：

声明宏示例 
macro_rules! vec_strs {
    ($($element:expr),*) => {
        {
            let mut v = Vec::new();
            $(
                v.push(String::from($element));
            )*
            v
        }
    };
}

fn main() {
    let v = vec_strs!["Hello", "World", "!"];
    println!("{:?}", v);
}

过程宏

过程宏允许我们创建自定义派生实现：

过程宏示例 
use proc_macro::TokenStream;

#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse(input).unwrap();
    impl_hello_macro(&ast)
}

fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
    let name = &ast.ident;
    let gen = quote! {
        impl HelloMacro for #name {
            fn hello_macro() {
                println!("Hello, Macro! My name is {}", stringify!(#name));
            }
        }
    };
    gen.into()
}

练习

通过以下练习掌握设计模式：

  1. 使用构建者模式实现配置系统
  2. 实现一个使用状态模式的工作流系统
  3. 使用访问者模式处理异构数据结构
返回首页