如何正确地序列化/反序列化铁锈

Question

我有多个结构，它们对应于只有在运行时才知道的序列化/反序列化对象，例如：

#[derive(Serialize, Deserialize)]
struct Car{
model: i32,
year: i32
}
#[derive(Serialize, Deserialize)]
struct Person{
name: String,
age: i32
}

然后我有了序列化和反序列化的函数：

fn deserialize(data: Vec<u8>){
let msg = str::from_utf8(data);
serde_json::from_str(msg);
}
fn serialize(&self, object: Car) -> String{
let msg = serde_json::to_string(&object).unwrap();
return msg;
}

如何使反序列化函数反序列化为Car和Person(可能还有许多其他不同的类型(并返回对象？我如何让序列化函数做同样的事情：序列化Car、Person和其他对象(在函数的属性中接受这些类型(？

Answer 1

您希望使用泛型函数来允许传入不同的类型，并设置特征边界以确保对象能够被序列化/反序列化。调用serialize时，类型将根据参数的类型推断，但调用deserialize时，如果无法推断，则需要使用Turbo fish(::<>(来指定类型。

use serde::{Serialize, Deserialize};
use std::str;
#[derive(Serialize, Deserialize)]
struct Car {
model: i32,
year: i32
}
#[derive(Serialize, Deserialize)]
struct Person {
name: String,
age: i32
}
// constrain output types to have the `Deserialize` trait
fn deserialize<'a, T>(data: &'a [u8]) -> T where T: Deserialize<'a> {
let msg = str::from_utf8(data).unwrap();
serde_json::from_str::<T>(msg).unwrap()
}
// shorthand for the above when `T` isn't needed in the function body
fn serialize(object: &impl Serialize) -> String {
let msg = serde_json::to_string(object).unwrap();
return msg;
}
fn main() {
let car = Car { model: 7, year: 2077 };
let person = Person { name: "Bob".to_string(), age: 42 };
// types are infrerred from the parameters
let car_json = serialize(&car);
let person_json = serialize(&person);
let _: Car = deserialize(car_json.as_bytes()); // output type can be inferred
let _ = deserialize::<Car>(car_json.as_bytes()); // requres turbofish
let _: Person = deserialize(person_json.as_bytes()); // works for `Person` too
}

Answer 2

您可以使deserialize通用于Deserialize特性：

fn deserialize<'a, T: Deserialize<'a>>(data: &'a [u8]) -> T {
let msg = str::from_utf8(data).unwrap();
serde_json::from_str(msg).unwrap()
}

请注意，您需要一些生存期，因为有些类型需要借用反序列化字符串doc。

您也可以使serialize通用：

fn serialize<T: Serialize>(object: &T) -> String {
serde_json::to_string(object).unwrap()
}

操场