Rust响应式状态管理库reactive_stores_macro使用指南

概述

reactive_stores_macro是一个基于宏的响应式状态管理库，通过宏驱动实现Store模式，提供高效的状态管理解决方案。该库利用Rust的宏系统简化状态管理代码，支持响应式状态更新和组件间状态共享。

核心特性

• 宏驱动的Store定义
• 响应式状态更新
• 高效的状态变更通知
• 类型安全的API设计
• 零成本抽象

安装方法

在Cargo.toml中添加依赖：

[dependencies]
reactive_stores_macro = "0.1"

基本使用方法

1. 定义Store

use reactive_stores_macro::store;

#[store]
struct CounterStore {
    count: i32,
    name: String,
}

impl CounterStore {
    // 自动生成new()方法
    // 自动生成getter和setter方法
}

2. 创建Store实例

let mut store = CounterStore::new(0, "Counter".to_string());

3. 状态更新

// 直接设置状态
store.set_count(42);
store.set_name("Updated Counter".to_string());

// 通过方法更新状态
store.update(|state| {
    state.count += 1;
    state.name = "Incremented".to_string();
});

4. 状态订阅

// 订阅状态变化
let subscription = store.subscribe(|state| {
    println!("Count changed to: {}", state.count);
});

// 取消订阅
subscription.unsubscribe();

5. 派生状态

#[store]
struct UserStore {
    first_name: String,
    last_name: String,
    
    #[computed]
    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

高级用法

异步状态更新

#[store]
struct AsyncStore {
    data: Option<String>,
    loading: bool,
}

impl AsyncStore {
    async fn fetch_data(&mut self) {
        self.set_loading(true);
        
        // 模拟异步操作
        let result = some_async_function().await;
        
        self.update(|state| {
            state.data = Some(result);
            state.loading = false;
        });
    }
}

状态持久化

#[store(persist = "local")]
struct PersistentStore {
    preferences: HashMap<String, String>,
}

完整示例

use reactive_stores_macro::store;

#[store]
struct AppState {
    counter: i32,
    theme: String,
    
    #[computed]
    fn is_dark_mode(&self) -> bool {
        self.theme == "dark"
    }
}

fn main() {
    let mut app_state = AppState::new(0, "light".to_string());
    
    // 订阅状态变化
    let _sub = app_state.subscribe(|state| {
        println!(
            "Counter: {}, Theme: {}, Dark Mode: {}",
            state.counter,
            state.theme,
            state.is_dark_mode()
        );
    });
    
    // 更新状态
    app_state.set_counter(42);
    app_state.set_theme("dark".to_string());
    
    // 批量更新
    app_state.update(|state| {
        state.counter += 10;
        state.theme = "light".to_string();
    });
}

最佳实践

1. 将Store定义在模块级别以便全局访问
2. 使用派生状态减少重复计算
3. 合理使用订阅机制避免内存泄漏
4. 对于复杂状态考虑使用嵌套Store结构

注意事项

• 确保在合适的作用域内管理Store生命周期
• 避免在Store中存储过多数据
• 合理处理错误状态
• 考虑使用Arc<Mutex<Store>>实现线程间共享

这个库通过宏简化了状态管理代码，提供了类型安全和高效的响应式状态管理方案。

完整示例demo

use reactive_stores_macro::store;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;

// 定义应用状态Store
#[store]
struct AppStore {
    counter: i32,
    user_name: String,
    preferences: HashMap<String, String>,
    
    #[computed]
    fn greeting(&self) -> String {
        format!("Hello, {}! Counter is at: {}", self.user_name, self.counter)
    }
}

// 异步数据获取函数模拟
async fn fetch_user_data() -> String {
    // 模拟网络请求延迟
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    "John Doe".to_string()
}

#[tokio::main]
async fn main() {
    // 创建Store实例
    let mut app_store = AppStore::new(
        0, 
        "Guest".to_string(), 
        HashMap::new()
    );
    
    // 设置初始偏好
    app_store.update(|state| {
        state.preferences.insert("theme".to_string(), "dark".to_string());
        state.preferences.insert("language".to_string(), "en".to_string());
    });
    
    // 订阅状态变化
    let subscription = app_store.subscribe(|state| {
        println!("状态更新: {}", state.greeting());
        println!("当前主题: {}", state.preferences.get("theme").unwrap());
    });
    
    // 同步状态更新
    println!("=== 同步状态更新 ===");
    app_store.set_counter(42);
    app_store.set_user_name("Alice".to_string());
    
    // 批量更新
    app_store.update(|state| {
        state.counter += 10;
        state.preferences.insert("theme".to_string(), "light".to_string());
    });
    
    // 异步状态更新
    println!("=== 异步状态更新 ===");
    let store_ref = Arc::new(Mutex::new(app_store));
    let store_clone = Arc::clone(&store_ref);
    
    tokio::spawn(async move {
        let user_name = fetch_user_data().await;
        let mut store = store_clone.lock().unwrap();
        store.set_user_name(user_name);
        store.set_counter(100);
    }).await.unwrap();
    
    // 访问最终状态
    let final_store = store_ref.lock().unwrap();
    println!("最终状态: {}", final_store.greeting());
    println!("所有偏好: {:?}", final_store.preferences);
    
    // 取消订阅
    subscription.unsubscribe();
    
    // 多线程示例
    println!("=== 多线程示例 ===");
    let shared_store = Arc::new(Mutex::new(AppStore::new(0, "Shared".to_string(), HashMap::new())));
    
    let handles: Vec<_> = (0..3).map(|i| {
        let store_clone = Arc::clone(&shared_store);
        thread::spawn(move || {
            let mut store = store_clone.lock().unwrap();
            store.set_counter(store.counter + i);
            println!("线程 {} 设置计数器为: {}", i, store.counter);
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    let final_shared = shared_store.lock().unwrap();
    println!("多线程操作后的计数器: {}", final_shared.counter);
}

这个完整示例展示了reactive_stores_macro库的核心功能：

1. Store的定义和实例化
2. 同步和异步状态更新
3. 状态订阅和取消订阅
4. 派生状态的使用
5. 多线程环境下的状态管理
6. 批量状态更新操作

示例中包含了详细的注释说明每个操作的作用和用法，帮助开发者更好地理解如何使用这个响应式状态管理库。