Deserialize的自定义实现通常是这种“复杂”反序列化的最佳解决方案：

impl<'de> Deserialize<'de> for Type {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<D, D::Error> {
        deserializer.deserialize_map(DeVisitor)
    }
}

struct DeVisitor;
impl<'de> de::Visitor<'de> for DeVisitor {
    type Value = Type;
    fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.write_str("a type")
    }
    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
        // could use another custom Deserialize to avoid
        // allocation and improve error messages
        let type_key = map.next_key::<String>()?;
        if type_key.as_deref() != Some("type") {
            return Err(de::Error::missing_field("type"));
        }
        // You can also use a Vec<String> here so you avoid TypeField, at
        // the gain of less boilerplate but at cost of worse error messages
        let r#type = map.next_value::<TypeField>()?;
        match r#type {
            Type::Story => {
                #[derive(Deserialize)]
                struct Story {
                    id: String,
                    name: string,
                    duration: u32,
                }
                let story = Story::deserialize(MapAccessDeserializer::new(map))?;
                // Construct your Type
            } // etc
        }
    }
}

enum TypeField {
    Story,
    Layer,
    Unknown(String),
}

// The manual Deserialize implementation you had above
// goes here

上述方法的一个很大的限制是它要求"type"字段是第一个字段。如果你想避免这种情况，最简单的方法取决于数据格式。例如，使用JSON，它可能看起来像这样：

let mut type_field = None;
let mut data = <Vec<(String, Box<serde_json::value::RawValue)>>::new();
while let Some(key) = map.next_key()? {
    if key == "type" {
        if type_field.is_some() {
            return Err(de::Error::duplicate_field("type"));
        }
        type_field = Some(map.next_value()?);
    } else {
        data.push((key, map.next_value()?));
    }
}
// Now you can match on type_field and use MapDeserializer
// to deserialize from `data`

所提供的答案非常完整，而且正确。但是，永远不要低估使用默认的东西和一点前一步的方便性。在这种特殊情况下（我并不是说这可以应用于所有类似的情况），在反序列化之前对数据进行规范化可能是最简单的事情。源类型几乎就在那里了，唯一的小缺点是它被 Package 在一个无用的列表中（这只是来自不同编程语言的序列化工件）。所以，我重复一遍，在这个特定的例子中，处理这个小细节比编写一个完整的新反序列化器要容易得多，特别是因为这种格式有点复杂。
所以这就是我现在要做的，展开类型，然后让正常的serde反序列化发生。

// Normalize the data from the DB so the "type" is just a string rather than a list with a
// single string in it.
let items = items
.iter()
.map(|item| {
    let mut item = item.to_owned();
    item.entry("type".to_owned()).and_modify(|v| {
        // if it is already a plain string, no need to unwrap
        if !v.is_s() {
            *v = v
                .as_l()
                .map_err(|_err| {
                    GetError::DataError(
                        "Expected db item 'type' field to be a list or a string",
                    )
                })
                .unwrap()
                .get(0)
                .unwrap()
                .to_owned();
        }
    });
    item
})
.collect::<Vec<_>>();

现在，您可以正常地反序列化，而无需为内部标记的枚举定义任何自定义反序列化：

let stories: Vec<StoryPart> = from_items(items.clone())?