Rust 如果我已经与serde json值进行了转换，如何实现序列化和反序列化？

我的大多数结构和枚举的序列化和反序列化可以使用

#[派生（序列化，反序列化）]

轻松实现

一些结构需要精心设计才能实现。我不熟悉

serde

。我成功地实现了

From

trait，用

Rc

s和

RefCell

s和

Option

s等将结构和枚举的一个特别复杂的组合层次结构转换为

serde_json:：Value

。既然我有了这个转换，我可以利用它来实现

序列化

和

反序列化

特征吗？我的最终目标是与web服务REST调用进行JSON转换

例如，我将一个名为

ShyValue

的类型转换为

Value

，分为两部分：

impl From<&ShyScalar> for Value {
    /// Create a Serde Value from a ShyScalar.
    /// Since Serde Values can only represent what is valid for JSON (e.g. no NaN values),
    /// encode unsupported values as Value::Strings, often by prepending a suffix.
    /// The reverse conversion will need to parse these strings out and reconstruct the proper ShyValue.
    fn from(s: &ShyScalar) -> Self {
        match s {
            // ... lots of code removed ...
        }
    }
}

impl From<&ShyValue> for Value {
    fn from(v: &ShyValue) -> Self {
        match v {
            ShyValue::Scalar(scalar) => scalar.into(),
            // ... lots more code removed ...
        }
    }
}

impl From for Value{
///从ShyScalar创建一个Serde值。
///由于Serde值只能表示对JSON有效的内容（例如，无NaN值），
///将不支持的值编码为Value:：string，通常是通过在后缀前加上前缀。
///反向转换将需要解析这些字符串并重新构造正确的ShyValue。
fn来自（s:&ShyScalar）->Self{
火柴{
//…删除了很多代码。。。
}
}
}
从中求值{
fn from（v:&ShyValue）->Self{
比赛五{
ShyValue:：Scalar（Scalar）=>Scalar.into（），
//…删除了更多的代码。。。
}
}
}

然后我在另一个方向进行了转换：

impl From<&Value> for ShyValue {
    fn from(v: &Value) -> Self {
        match v {
            Value::Null => ShyValue::Scalar(ShyScalar::Null),
            Value::Bool(b) => b.into(),

            // A Value::String may represent any of several ShyValue variants, so must be parsed.
            // The prefix (if any) usually determines which variant to create.
            Value::String(ref nan) if nan.to_lowercase() == "nan" => {
                ShyValue::Scalar(f64::NAN.into())
            }
            Value::String(ref err) if err.starts_with("Error: ") => {
                ShyValue::error(err[7..].into())
            }
            Value::String(ref func_name) if func_name.starts_with("FunctionName: ") => {
                ShyValue::FunctionName(func_name[13..].into())
            }
            Value::String(ref prop_chain) if prop_chain.starts_with("PropertyChain: ") => {
                ShyValue::property_chain(prop_chain[15..].into())
            }
            Value::String(ref variable) if variable.starts_with("Variable: ") => {
                ShyValue::Variable(variable[10..].into())
            }
            Value::String(s) => s.clone().into(),

            Value::Number(ref n) if (*n).is_i64() => {
                ShyValue::Scalar(ShyScalar::Integer(n.as_i64().unwrap()))
            }
            Value::Number(ref f) => ShyValue::Scalar(ShyScalar::Rational(f.as_f64().unwrap())),
            Value::Array(a) => ShyValue::Vector(
                a.iter()
                    .map(|item| match item {
                        Value::Null => ShyScalar::Null,
                        Value::Bool(b) => (*b).into(),
                        Value::String(s) => s.clone().into(),
                        Value::Number(ref n) if (*n).is_i64() => {
                            ShyScalar::Integer(n.as_i64().unwrap())
                        }
                        Value::Number(ref f) => ShyScalar::Rational(f.as_f64().unwrap()),
                        _ => ShyScalar::Error("Unsupported type of scalar".into()),
                    })
                    .collect(),
            ),
            Value::Object(o) => {
                let shy_object = ShyObject::empty();
                {
                    let mut assoc = shy_object.as_deref_mut();
                    for (key, value) in o {
                        assoc.set(key, value.into());
                    }
                }
                ShyValue::Object(shy_object)
            }
        }
    }
}

impl From for ShyValue{
fn from（v:&Value）->Self{
比赛五{
Value:：Null=>ShyValue:：Scalar（ShyScalar:：Null），
Value:：Bool（b）=>b.into（），
//Value:：String可以表示多个ShyValue变量中的任意一个，因此必须进行解析。
//前缀（如果有）通常决定要创建的变体。
Value:：String（ref nan）if nan.to_lowercase（）=“nan”=>{
ShyValue:：Scalar（f64:：NAN.into（））
}
Value：：字符串（ref err）如果err.以（“Error:”）=>{
ShyValue:：error（err[7..].into（））
}
Value:：字符串（ref func_name）如果func_name.以（“FunctionName:”）开头=>{
ShyValue:：FunctionName（函数名[13..].into（））
}
Value:：字符串（ref prop\u chain），如果prop\u chain.以（“PropertyChain:”）开头=>{
ShyValue:：属性链（属性链[15..].into（））
}
Value:：String（ref变量）if variable.以（“变量：”）=>{
ShyValue:：Variable（变量[10..].into（））
}
Value:：String=>s.clone（）.into（），
Value:：Number（ref n）if（*n）.is_i64（）=>{
ShyValue:：Scalar（ShyScalar:：Integer（n.as_i64（）.unwrap（））
}
Value:：Number（ref f）=>ShyValue:：Scalar（ShyScalar:：Rational（f.as_f64（）.unwrap（）），
Value:：Array（a）=>ShyValue:：Vector(
a、 iter（）
.map（|项|匹配项{
Value:：Null=>ShyScalar:：Null，
Value:：Bool（b）=>（*b）.into（），
Value:：String=>s.clone（）.into（），
Value:：Number（ref n）if（*n）.is_i64（）=>{
ShyScalar:：Integer（n.as_i64（）.unwrap（））
}
Value:：Number（ref f）=>ShyScalar:：Rational（f.as_f64（）.unwrap（）），
_=>ShyScalar:：Error（“不支持的标量类型“.into（）），
})
.collect（），
),
值：：对象（o）=>{
让shy_object=ShyObject:：empty（）；
{
让mut assoc=shy_object.as_deref_mut（）；
用于o中的（键、值）{
assoc.set（key，value.into（））；
}
}
ShyValue:：对象（shy_对象）
}
}
}
}

您的问题似乎可以由/的答案来回答。如果没有，请回答您的问题以解释差异。否则，我们可以将此问题标记为已回答。谢谢！其中一个答案看起来可能有用。。