Question

我试图将JSON反序列化为包含可选字段authorization的结构。 JSON可能包含也可能不包含此字段。如果确实包含该字段，我正在对hyper::header::Authorization<hyper::header::Scheme>进行自定义反序列化。因为Authorization需要Scheme的泛型类型，所以我需要（正如我所写的那样）在我的结构中包含泛型类型。

所有测试都通过了，但最后一个（de_json_none，JSON 没有授权字段的那个）在语义上很奇怪，因为我必须使用明确的{目标变量} {1}}类型（显示为Scheme或Bearer），尽管从Rust的角度来看完全有效，但它们对这些数据都没有任何意义。

很清楚为什么会这样，但这是我不想要的东西以及我不确定如何修复的东西。

我想编写一个Rocket处理程序，它只通过将数据类型设置为Basic来匹配包含Authorization<Bearer>类型的授权字段的数据。目前，它还会匹配根本没有该字段的数据。我也没有一个明确的方法来特别按类型调用缺少字段的数据。

我正在寻找有关如何重构此代码的建议，以反映Headers<Bearer>确实有三个不同的，相互排斥的化身（Headers，Basic和{{1 }}）。也许我应该在这里用枚举做点什么？

Bearer

Answer 1

There's no concept of a None without a corresponding Some type。编译器需要知道为大小写的值分配多少空间：

struct ReallyBig([u8; 1024]);
struct ReallySmall(u8);

fn main() {
    let mut choice = None; // How much space to allocate?
}

在您的代码中，Authorization的大小取决于为S选择的值。由于Headers包含Option<Authorization<S>>，Headers 的大小也可能取决于S的选择。

即使没有价值，也必须选择解析某些特定类型。也许您稍后会通过构建适当的值手动将其从None更改为Some - 如果没有足够的空间分配，那就麻烦了！

因此，我无法看到您的解决方案如何运作。类型是静态的 - 如果解码JSON将导致Authorization或Bearer，则需要在编译时知道，并且这根本不可能。< / p>

通常情况下，我建议您使用动态调度Box<Scheme>。这不会在这里工作，因为Scheme不是对象安全的。

然后，我建议你实现自己的枚举包装Basic或Box并为此实现Scheme。这并不容易，因为Scheme::scheme必须返回单个关键字，但实际上您支持两个关键字！

下一步是实现我们自己的Header：

extern crate hyper;
extern crate serde;
extern crate serde_json;
#[macro_use]
extern crate serde_derive;

use hyper::header::{Authorization, Header, Raw, Basic, Bearer};
use serde::{Deserialize, Deserializer};
use std::fmt;

#[derive(Debug, Clone, PartialEq)]
enum MyAuthorization {
    Basic(Authorization<Basic>),
    Bearer(Authorization<Bearer>),
}

impl Header for MyAuthorization {
    fn header_name() -> &'static str {
        // Should always be the same header name, right?
        Authorization::<Basic>::header_name()
    }

    fn parse_header(raw: &Raw) -> hyper::error::Result<Self> {
        Authorization::<Basic>::parse_header(raw)
            .map(MyAuthorization::Basic)
            .or_else(|_| {
                Authorization::<Bearer>::parse_header(raw).map(MyAuthorization::Bearer)
            })
    }

    fn fmt_header(&self, f: &mut hyper::header::Formatter) -> fmt::Result {
        match *self {
            MyAuthorization::Basic(ref a) => a.fmt_header(f),
            MyAuthorization::Bearer(ref a) => a.fmt_header(f),
        }
    }
}

#[derive(Debug, Deserialize, PartialEq)]
struct Headers {
    #[serde(deserialize_with = "auth_header", default)]
    authorization: Option<MyAuthorization>,
    #[serde(rename = ":path")]
    path: String,
}

fn auth_header<'de, D>(deserializer: D) -> Result<Option<MyAuthorization>, D::Error>
where
    D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    let auth = MyAuthorization::parse_header(&Raw::from(s.into_bytes()));
    auth.map(Some).map_err(serde::de::Error::custom)
}

#[cfg(test)]
mod test {
    use hyper::header::{Basic, Bearer};
    use serde_json;
    use super::*;

    #[test]
    fn de_json_basic() {
        let data = r#"{
                        "authorization": "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==",
                        ":path": "/service/",
                        ":method": "GET"
                      }"#;

        let message = Headers {
            authorization: Some(MyAuthorization::Basic(Authorization(Basic {
                username: "Aladdin".to_owned(),
                password: Some("open sesame".to_owned()),
            }))),
            path: "/service/".to_owned(),
        };

        let h: Headers = serde_json::from_str(data).unwrap();

        assert_eq!(message, h);
    }

    #[test]
    fn de_json_bearer() {
        let data = r#"{
                        "authorization": "Bearer fpKL54jvWmEGVoRdCNjG",
                        ":path": "/service/",
                        ":method": "GET"
                      }"#;

        let message = Headers {
            authorization: Some(MyAuthorization::Bearer(Authorization(
                Bearer { token: "fpKL54jvWmEGVoRdCNjG".to_owned() },
            ))),
            path: "/service/".to_owned(),
        };

        let h: Headers = serde_json::from_str(data).unwrap();

        assert_eq!(message, h);
    }

    #[test]
    fn de_json_none() {
        let data = r#"{
                        ":path": "/service/",
                        ":method": "GET"
                      }"#;

        let message = Headers {
            authorization: None,
            path: "/service/".to_owned(),
        };

        let h: Headers = serde_json::from_str(data).unwrap();

        assert_eq!(message, h);
    }
}

您可能希望与Hyper维护人员联系，看看这是否是预期的做法。

使用泛型类型反序列化可选的struct字段会导致语义怪异

1 个答案: