Lib.rs

struct Order {
    user_id: u64,
    amount: u64,
    address: String,
    #[serde(default)]
    comments: Option<String>,
    shipping_required: bool,
    status: OrderStatus,
    id: Uuid,
    assigned_employee_id: Option<u64>,
}

然后是 OrderRequest，它将不会包含 id 字段，因为它被标记为 #[boilermates(not_in("OrderRequest"))]，status 字段因为它在 #[boilermates(only_in("Order", "OrderResponse"))] 中未提及，以及 assigned_employee_id 字段，因为它被标记为 #[boilermates(only_in_self)]，这相当于 #[boilermates(only_in("Order"))]。然而，它将包含 jwt_token。

struct OrderRequest {
    user_id: u64,
    amount: u64,
    address: String,
    #[serde(default)]
    comments: Option<String>,
    shipping_required: bool,
    jwt_token: String,
}

最后，OrderResponse 将包含 Order 所有的内容，加上 response_code 字段，但不包含 assigned_employee_id 字段，这显然与客户无关。

struct OrderResponse {
    user_id: u64,
    amount: u64,
    address: String,
    #[serde(default)]
    comments: Option<String>,
    shipping_required: bool,
    id: Uuid,
    status: OrderStatus,
    response_code: ResponseCode,
}

转换

现在来点有趣的东西。假设我们通过API接收到了一个新的订单，并且在 request 变量中有一个 OrderRequest 对象。我们可以轻松地将它转换为 Order，只需要填写缺失的数据。我们可以有两种方法来做这件事。首先，使用 into_order 方法，该方法按照原始 struct 声明中定义的顺序接受 Order 缺失的参数。它的签名是 pub fn into_order(self, id: Uuid, status: OrderStatus assigned_employee_id: Option<u64> ) -> Order，所以我们可以这样操作

let order = request.into_order(Uuid::new_v4(), OrderStatus::Received, None);

但是，status 和 assigned_employee_id 被标记为 #[boilermates(default)]，所以当我们想要将这些字段转换为具有这些字段的类型时使用默认值，我们可以使用

let order = request.into_order_defaults(Uuid::new_v4);

接下来，在我们成功将订单保存到数据库后，我们可以这样将其转换为 OrderResponse

let response = order.into_order_response(ResponseCode::Ok);

但是，由于 ResponseCode 有一个 Default 实现，return_code 被标记为 #[boilermates(default)]，并且所有其他来自 Order 的字段都包含在 OrderResponse 中，我们可以这样做

let response = OrderResponse::from(order); // or `let response: OrderResponse = order.into()`

当转换不需要额外参数时，所有情况都实现了 From/Into 转换。

泛型实现

每个字段都会触发生成一个带有获取器方法 fn {field}(&self) -> &{field_type} 的 Has{Field} 特性，以及一个设置器方法 fn set_{field}(&mut self, value: &{field_type})，每个具有字段的 struct 都有相应的实现。

由于这3个结构体共享大量相同的数据，它们可以实现一些相同的功能。例如，如果我们想找出订单总额是多少（还记得示例开头中的 UNIT_PRICE 和 SHIPPING_PRICE 吗？），我们可以创建一个通用的实现，使用 HasAmount 和 HasShippingRequired 特性，这些特性已经为所有具有 amount 和 shipping_required 字段的类型实现。这允许我们像这样使用 amount() 和 shipping_required() 获取器方法

// These work out of the box:
request.set_amount(10);
order.set_amount(10);
response.set_amount(10);

trait GetTotal: HasAmount + HasShippingRequired {
    fn total(&self) -> u64 {
        self.amount() * UNIT_PRICE
            + if *self.shipping_required() {
                SHIPPING_PRICE
            } else {
                0
            }
    }
}
impl<T: HasAmount + HasShippingRequired> GetTotal for T {}

// Now all of these work:
let total = request.total()
let total = order.total()
let total = response.total()