如何提高Rust序列化性能？- 2
在上一篇文章中，我们手动实现Serde库中的Serialize trait， 提高了序列化的性能。但是不能使用默认的#[derive(Serialize)]功能，在这一篇文章中，我们来解决这个问题，使这两种情景可以兼容。
格式化器
我们不要在数据类型上直接手动实现Serialize trait。相反，应该在类似格式化器的封装类型上实现它。
struct DisplayFormatter<T: Display>(T);
impl<T: Display> Serialize for DisplayFormatter<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(&self.0)
}
}
此泛型格式器封装了实现Display的类型T，并使用该表示对T进行序列化。你不仅可以在Name类型上使用它，还可以在任何实现Display的类型上使用它。
struct FullNameFormatter<'a>(&'a Name);
impl<'a> Serialize for FullNameFormatter<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(&format_args!("{} {}", self.0.first_name, self.0.last_name))
}
}
这里，我们直接使用format_args!宏，像println!宏和format!宏在底层使用的就是format_args!宏。它返回Arguments，重要的是Arguments实现了collect_str()方法所需的Display。
fn formatter(names: &[Name]) -> serde_json::Result<String> {
let full_names = names.iter().map(FullNameFormatter).collect::<Vec<_>>();
serde_json::to_string(&full_names)
}
我们将每个&Name映射到FullNameFormatter(&Name)，并将映射收集到一个向量中，然后将该向量传递给serde_json进行序列化。
serialization fastest │ slowest │ median │ mean │ samples │ iters
├─ ser_formatter │ │ │ │ │
│ ├─ 0 282.2 ms │ 502 ms │ 294 ms │ 312.4 ms │ 100 │ 100
..........
│ ╰─ 20 99.15 ms │ 222.2 ms │ 110.4 ms │ 116.2 ms │ 100 │ 100
╰─ ser_manual_serialize │ │ │ │ │
├─ 0 172 ms │ 299.8 ms │ 175.6 ms │ 184 ms │ 100 │ 100
..........
╰─ 20 95.45 ms │ 127.9 ms │ 99.34 ms │ 100.7 ms │ 100 │ 100
几乎没性能差异，因为封装器类型在Rust中是零成本抽象。
但实际上，应该有一个与封装器类型本身无关的额外成本。在上面的测试结果中应该会看到，对于低N值，此方法的性能略低于manual_serialize
这是因为有一次收集map数据并进行Vec的分配！这种分配几乎没有出现在基准测试结果中，特别是对于较高的N值。这是因为它只执行一次，与序列化本身相比，它的开销可以忽略不计。
序列格式化器
我们不能跳过收集map数据并将Iterator传递给serde_json序列化器的过程，因为Serde库不直接支持Iterator的序列化。Serialize trait没有被Iterator实现，但是Serde的Serializer提供了collect_seq方法来收集Iterator。
struct FullNameSequenceFormatter<'a>(&'a [Name]);
impl<'a> Serialize for FullNameSequenceFormatter<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_seq(self.0.iter().map(FullNameFormatter))
}
}
fn sequence_formatter(names: &[Name]) -> serde_json::Result<String> {
serde_json::to_string(&FullNameSequenceFormatter(names))
}
serialization fastest │ slowest │ median │ mean │ samples │ iters
├─ ser_manual_serialize │ │ │ │ │
│ ├─ 0 170.6 ms │ 358.9 ms │ 185.8 ms │ 193.5 ms │ 100 │ 100
............
│ ╰─ 20 97.34 ms │ 143.5 ms │ 101.2 ms │ 106.2 ms │ 100 │ 100
╰─ ser_sequence_formatter │ │ │ │ │
├─ 0 172.8 ms │ 225.5 ms │ 183.3 ms │ 186.7 ms │ 100 │ 100
............
╰─ 20 97.89 ms │ 152.6 ms │ 99.4 ms │ 102 ms │ 100 │ 100
总结
“避免分配”是这两篇文章的真正结论，更具体地说，应该是避免在序列化之前分配数据的中间状态。