Rust领域驱动设计宏库domain-macros的使用，简化领域模型代码生成与DDD模式实现

domain-macros是一个Rust宏库，旨在简化领域驱动设计(DDD)模式的实现，通过自动生成领域模型代码来提高开发效率。

安装

在项目目录中运行以下Cargo命令：

cargo add domain-macros

或者在Cargo.toml中添加：

domain-macros = "0.11.0"

基本使用示例

以下是一个使用domain-macros实现简单领域模型的完整示例：

use domain_macros::{entity, value_object};

// 定义一个值对象
#[value_object]
pub struct Email(String);

impl Email {
    pub fn new(email: String) -> Result<Self, String> {
        if email.contains('@') {
            Ok(Email(email))
        } else {
            Err("Invalid email format".to_string())
        }
    }
}

// 定义一个实体
#[entity]
pub struct User {
    id: u64,
    email: Email,
    name: String,
}

impl User {
    pub fn new(id: u64, email: Email, name: String) -> Self {
        User { id, email, name }
    }
}

// 使用示例
fn main() {
    let email = Email::new("test@example.com".to_string()).unwrap();
    let user = User::new(1, email, "John Doe".to_string());
    
    println!("User ID: {}", user.id());
    println!("User Email: {}", user.email().0);
    println!("User Name: {}", user.name());
}

主要特性

1. #[entity]宏自动为结构体生成:

   • getter方法
   • 标识符比较功能
   • 基本领域对象特征实现

2. #[value_object]宏提供:

   • 值对象语义
   • 不可变性保证
   • 值相等性比较

3. 其他领域模式支持:

   • 聚合根
   • 领域事件
   • 仓储模式

完整示例demo

以下是一个更完整的领域模型示例，展示聚合根和值对象的使用：

use domain_macros::{entity, value_object, aggregate_root};
use uuid::Uuid;

// 值对象 - 地址
#[value_object]
pub struct Address {
    street: String,
    city: String,
    zip_code: String,
}

impl Address {
    pub fn new(street: String, city: String, zip_code: String) -> Self {
        Address { street, city, zip_code }
    }
}

// 实体 - 订单项
#[entity]
pub struct OrderItem {
    id: Uuid,
    product_id: Uuid,
    quantity: u32,
    unit_price: f64,
}

impl OrderItem {
    pub fn new(product_id: Uuid, quantity: u32, unit_price: f64) -> Self {
        OrderItem {
            id: Uuid::new_v4(),
            product_id,
            quantity,
            unit_price,
        }
    }
    
    pub fn total_price(&self) -> f64 {
        self.quantity as f64 * self.unit_price
    }
}

// 聚合根 - 订单
#[aggregate_root]
pub struct Order {
    id: Uuid,
    customer_id: Uuid,
    items: Vec<OrderItem>,
    shipping_address: Address,
    status: String,
}

impl Order {
    pub fn new(customer_id: Uuid, shipping_address: Address) -> Self {
        Order {
            id: Uuid::new_v4(),
            customer_id,
            items: Vec::new(),
            shipping_address,
            status: "Created".to_string(),
        }
    }
    
    pub fn add_item(&mut self, product_id: Uuid, quantity: u32, unit_price: f64) {
        self.items.push(OrderItem::new(product_id, quantity, unit_price));
    }
    
    pub fn total_amount(&self) -> f64 {
        self.items.iter().map(|item| item.total_price()).sum()
    }
    
    pub fn ship(&mut self) {
        self.status = "Shipped".to_string();
    }
}

// 使用示例
fn main() {
    let address = Address::new(
        "123 Main St".to_string(),
        "New York".to_string(),
        "10001".to_string()
    );
    
    let mut order = Order::new(Uuid::new_v4(), address);
    
    order.add_item(Uuid::new_v4(), 2, 19.99);
    order.add_item(Uuid::new_v4(), 1, 9.99);
    
    println!("Order ID: {}", order.id());
    println!("Total Amount: ${:.2}", order.total_amount());
    
    order.ship();
    println!("Order Status: {}", order.status());
}

许可证

BSD-3-Clause许可证