rust - serde/bincode 如何序列化字节数组？

Question

这段代码完全按照我的意愿序列化了一个 32 字节的数组:

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
struct Hash([u8; 32]);

let hash = Hash([1u8; 32]);
let hash_bin = bincode::serialize(&hash).unwrap();
assert_eq!(hash_bin, [1u8; 32]);

它是如何工作的？

根据 https://serde.rs/impl-serializer.html有一个 serialize_bytes() 函数，但 bincode 版本会在数据前添加一个长度。

fn serialize_bytes(self, v: &[u8]) -> Result<()> {
    O::IntEncoding::serialize_len(self, v.len())?;
    self.writer.write_all(v).map_err(Into::into)
}

代码(以上)调用 Serialize 中的什么函数，将 32 个字节序列化为它们本身，没有长度前缀？

---

上下文:我正在为一个类型实现一个客户序列化，我希望它(在某些情况下)序列化字节数组，以便 bincode 将它们编码为没有长度前缀的字节。这是一个问题，因为调用 serialize_bytes() 添加了一个长度前缀。

我想了解默认情况下字节数组是如何序列化的，因为我不知道要调用哪个方法来代替 serialize_bytes() 来获取没有长度前缀的字节。

Answer 1

怎么样[u8; N]和 [u8]序列化？

简而言之，这里是如何serde 1.0.151 实现了每个方法。 serialize_bytes实际上不是 serde 的一部分所以它被视为一个序列。

// [T; N] is serialized as a tuple. However, this is only implemented for N 0 to 32 inclusively.
let mut seq = try!(serializer.serialize_tuple(N));
for e in self {
    try!(seq.serialize_element(e));
}
seq.end()

// [T] is serialized as a sequence.
serializer.collect_seq(self)

方法 serialize_tuple和 collect_seq由您正在使用的特定序列化程序实现。

简单的方法

一个常见的问题是 serde只实现 Serialize/Deserialize对于长度不超过 32 的数组。最简单的方法是使用像 serde_with 这样的 crate 。它添加了额外的序列化/反序列化实现，您可以附加到您的结构。这是从他们的文档中摘录的示例:

#[serde_as]
#[derive(Deserialize, Serialize)]
struct Arrays<const N: usize, const M: usize> {
    #[serde_as(as = "[_; N]")]
    constgeneric: [bool; N],

    #[serde_as(as = "Box<[[_; 64]; N]>")]
    nested: Box<[[u8; 64]; N]>,

    #[serde_as(as = "Option<[_; M]>")]
    optional: Option<[u8; M]>,
}

我们如何自己实现它？ Rust Playground

Serialize

执行序列化实际上很容易。 Serde 没有数组的概念，所以我们需要在 serialize_tuple 之间进行选择。或 serialize_seq .在引擎盖下，唯一的区别是 serialize_seq可能没有已知长度，所以我们可以选择 serialize_tuple .

pub fn serialize<S, T, const N: usize>(this: &[T; N], serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    T: Serialize,
{
    let mut seq = serializer.serialize_tuple(N)?;
    for element in this {
        seq.serialize_element(element)?;
    }
    seq.end()
}

Deserialize

另一方面，反序列化变得有点复杂。我们需要定义一个访问者，然后指定应该如何访问每个元素。我写了一个例子来说明如何在数组的一般情况下完成它，但这不是最佳解决方案，因为它首先反序列化到堆栈上。我还必须使用 unsafe代码一次只初始化数组一个元素，但是unsafe如果T: Default，代码很容易被删除或者如果扩展数据结构像 Vec<T>而是使用。通常，这更旨在作为对序列实现反序列化的指南。

pub fn deserialize<'de, D, T, const N: usize>(deserializer: D) -> Result<[T; N], D::Error>
where
    D: Deserializer<'de>,
    T: 'de + Deserialize<'de>,
{
    deserializer.deserialize_seq(ArrayVisitor { _phantom: PhantomData })
}

struct ArrayVisitor<'de, T, const N: usize> {
    _phantom: PhantomData<&'de [T; N]>,
}

impl<'de, T, const N: usize> Visitor<'de> for ArrayVisitor<'de, T, N>
where
    T: Deserialize<'de>,
{
    type Value = [T; N];

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "array of length {}", N)
    }

    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: SeqAccess<'de>,
    {
        let mut array: MaybeUninit<[T; N]> = MaybeUninit::uninit();

        for index in 0..N {
            // Get next item as Result<Option<T>, A::Error>. Since we know
            // exactly how many elements we should receive, we can flatten
            // this to a Result<T, A::Error>.
            let next = seq.next_element::<T>()
                .and_then(|x| x.ok_or_else(|| Error::invalid_length(N, &self)));
        
            match next {
                Ok(x) => unsafe {
                    // Safety: We write into the array without reading any
                    // uninitialized memory and writes only occur within the
                    // array bounds at multiples of the array stride.
                    let array_base_ptr = array.as_mut_ptr() as *mut T;
                    ptr::write(array_base_ptr.add(index), x);
                },
                Err(err) => {
                    // Safety: We need to manually drop the parts we
                    // initialized before we can return.
                    unsafe {
                        let array_base_ptr = array.as_mut_ptr() as *mut T;

                        for offset in 0..index {
                            ptr::drop_in_place(array_base_ptr.add(offset));
                        }
                    }
                    
                    return Err(err)
                },
            }
        }

        // Safety: We have completely initialized every element
        unsafe { Ok(array.assume_init()) }
    }
}

如果有人好奇如何derive(Deserialize)适用于结构，我建议查看此 Rust Playground我在这里扩展了宏，然后清理了输出以使其更易于阅读。了解序列化/反序列化的工作原理确实有助于揭开这个过程的神秘面纱。