Rust语言从入门到精通系列 - 二进制自压缩序列化bincode模块

Bincode 是一个用于 Rust 语言的二进制编码库，用于将 Rust 结构体序列化为二进制格式，或者将二进制格式反序列化为 Rust 结构体。它支持大多数 Rust 原生类型和自定义类型，并且可以高效地处理大型数据结构。Bincode 还支持压缩和解压缩，以减小序列化后的数据大小。

基础用法#

序列化和反序列化一个简单的结构体#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Person {
5
    name: String,
6
    age: u8,
7
}
8

9
fn main() {
10
    let person = Person {
11
        name: "Alice".to_string(),
12
        age: 25,
13
    };
14

15
    // Serialize
16
    let encoded: Vec<u8> = serialize(&person).unwrap();
17

18
    // Deserialize
19
    let decoded: Person = deserialize(&encoded[..]).unwrap();
20

21
    assert_eq!(person, decoded);
22
}

在这个示例中，我们定义了一个Person结构体，它有一个name字段和一个age字段。我们将其序列化为一个字节数组，然后将其反序列化回Person结构体，并将其与原始结构体进行比较。

序列化和反序列化一个嵌套结构体#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Address {
5
    street: String,
6
    city: String,
7
    zip: String,
8
}
9

10
#[derive(Serialize, Deserialize, Debug, PartialEq)]
11
struct Person {
12
    name: String,
13
    age: u8,
14
    address: Address,
15
}
16

17
fn main() {
18
    let person = Person {
19
        name: "Alice".to_string(),
20
        age: 25,
21
        address: Address {
22
            street: "123 Main St".to_string(),
23
            city: "Anytown".to_string(),
24
            zip: "12345".to_string(),
25
        },
26
    };
27

28
    // Serialize
29
    let encoded: Vec<u8> = serialize(&person).unwrap();
30

31
    // Deserialize
32
    let decoded: Person = deserialize(&encoded[..]).unwrap();
33

34
    assert_eq!(person, decoded);
35
}

这个示例中，我们定义了一个Person结构体，它包含一个嵌套的Address结构体。我们将其序列化为一个字节数组，然后将其反序列化回Person结构体，并将其与原始结构体进行比较。

序列化和反序列化一个向量#

1
use bincode::{serialize, deserialize};
2

3
fn main() {
4
    let numbers = vec![1, 2, 3, 4, 5];
5

6
    // Serialize
7
    let encoded: Vec<u8> = serialize(&numbers).unwrap();
8

9
    // Deserialize
10
    let decoded: Vec<i32> = deserialize(&encoded[..]).unwrap();
11

12
    assert_eq!(numbers, decoded);
13
}

在这个示例中，我们定义了一个包含整数的向量。我们将其序列化为一个字节数组，然后将其反序列化回一个整数向量，并将其与原始向量进行比较。

序列化和反序列化一个哈希表#

1
use std::collections::HashMap;
2
use bincode::{serialize, deserialize};
3

4
fn main() {
5
    let mut map = HashMap::new();
6
    map.insert("Alice", 25);
7
    map.insert("Bob", 30);
8
    map.insert("Charlie", 35);
9

10
    // Serialize
11
    let encoded: Vec<u8> = serialize(&map).unwrap();
12

13
    // Deserialize
14
    let decoded: HashMap<&str, i32> = deserialize(&encoded[..]).unwrap();
15

16
    assert_eq!(map, decoded);
17
}

在这个示例中，我们定义了一个包含键值对的哈希表。我们将其序列化为一个字节数组，然后将其反序列化回一个哈希表，并将其与原始哈希表进行比较。

序列化和反序列化一个枚举#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
enum Color {
5
    Red,
6
    Green,
7
    Blue,
8
}
9

10
fn main() {
11
    let color = Color::Green;
12

13
    // Serialize
14
    let encoded: Vec<u8> = serialize(&color).unwrap();
15

16
    // Deserialize
17
    let decoded: Color = deserialize(&encoded[..]).unwrap();
18

19
    assert_eq!(color, decoded);
20
}

在这个示例中，我们定义了一个枚举类型Color，它有三个可能的值。我们将其序列化为一个字节数组，然后将其反序列化回一个Color枚举，并将其与原始枚举进行比较。

序列化和反序列化一个字符串#

1
use bincode::{serialize, deserialize};
2

3
fn main() {
4
    let message = "Hello, world!".to_string();
5

6
    // Serialize
7
    let encoded: Vec<u8> = serialize(&message).unwrap();
8

9
    // Deserialize
10
    let decoded: String = deserialize(&encoded[..]).unwrap();
11

12
    assert_eq!(message, decoded);
13
}

在这个示例中，我们定义了一个字符串。我们将其序列化为一个字节数组，然后将其反序列化回一个字符串，并将其与原始字符串进行比较。

压缩和解压缩序列化后的数据#

1
use bincode::{serialize, deserialize, config};
2
use flate2::{Compression, read::DeflateEncoder, write::DeflateDecoder};
3

4
fn main() {
5
    let numbers = vec![1, 2, 3, 4, 5];
6

7
    // Serialize
8
    let encoded: Vec<u8> = serialize(&numbers).unwrap();
9

10
    // Compress
11
    let mut compressed = Vec::new();
12
    let mut encoder = DeflateEncoder::new(&encoded[..], Compression::default());
13
    encoder.read_to_end(&mut compressed).unwrap();
14

15
    // Decompress
16
    let mut decompressed = Vec::new();
17
    let mut decoder = DeflateDecoder::new(&compressed[..]);
18
    decoder.read_to_end(&mut decompressed).unwrap();
19

20
    // Deserialize
21
    let decoded: Vec<i32> = deserialize(&decompressed[..]).unwrap();
22

23
    assert_eq!(numbers, decoded);
24
}

在这个示例中，我们定义了一个包含整数的向量。我们将其序列化为一个字节数组，然后将其压缩为另一个字节数组。我们将压缩后的字节数组解压缩为另一个字节数组，然后将其反序列化回一个整数向量，并将其与原始向量进行比较。

使用自定义配置序列化和反序列化#

1
use bincode::{serialize_with, deserialize_from, config};
2
use std::io::{Cursor, Write};
3

4
#[derive(Debug, PartialEq)]
5
struct Person {
6
    name: String,
7
    age: u8,
8
}
9

10
fn main() {
11
    let person = Person {
12
        name: "Alice".to_string(),
13
        age: 25,
14
    };
15

16
    // Serialize
17
    let mut buffer = Cursor::new(Vec::new());
18
    serialize_with(&mut buffer, &person, config().big_endian()).unwrap();
19
    let encoded = buffer.into_inner();
20

21
    // Deserialize
22
    let mut cursor = Cursor::new(encoded);
23
    let decoded: Person = deserialize_from(&mut cursor, config().big_endian()).unwrap();
24

25
    assert_eq!(person, decoded);
26
}

在这个示例中，我们定义了一个Person结构体，它有一个name字段和一个age字段。我们将其序列化为一个字节数组，并使用自定义配置将其编码为大端字节序。我们将编码后的字节数组反序列化回Person结构体，并使用相同的自定义配置来解码它。

进阶用法#

自定义序列化和反序列化#

1
use bincode::{serialize, deserialize, Error, ErrorKind};
2
use std::io::{Cursor, Write, Read};
3

4
#[derive(Debug, PartialEq)]
5
struct Person {
6
    name: String,
7
    age: u8,
8
}
9

10
impl Person {
11
    fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error> {
12
        let name_bytes = self.name.as_bytes();
13
        if name_bytes.len() > 255 {
14
            return Err(Error::new(ErrorKind::Custom("name too long".to_string())));
15
        }
16
        writer.write_all(&(name_bytes.len() as u8).to_le_bytes())?;
17
        writer.write_all(name_bytes)?;
18
        writer.write_all(&self.age.to_le_bytes())?;
19
        Ok(())
20
    }
21

22
    fn deserialize<R: Read>(reader: &mut R) -> Result<Self, Error> {
23
        let mut name_len_bytes = [0; 1];
24
        reader.read_exact(&mut name_len_bytes)?;
25
        let name_len = name_len_bytes[0] as usize;
26
        let mut name_bytes = vec![0; name_len];
27
        reader.read_exact(&mut name_bytes)?;
28
        let name = String::from_utf8(name_bytes)?;
29
        let mut age_bytes = [0; 1];
30
        reader.read_exact(&mut age_bytes)?;
31
        let age = age_bytes[0];
32
        Ok(Person { name, age })
33
    }
34
}
35

36
fn main() {
37
    let person = Person {
38
        name: "Alice".to_string(),
39
        age: 25,
40
    };
41

42
    // Serialize
43
    let mut buffer = Cursor::new(Vec::new());
44
    person.serialize(&mut buffer).unwrap();
45
    let encoded = buffer.into_inner();
46

47
    // Deserialize
48
    let mut cursor = Cursor::new(encoded);
49
    let decoded: Person = Person::deserialize(&mut cursor).unwrap();
50

51
    assert_eq!(person, decoded);
52
}

在这个示例中，我们定义了一个Person结构体，并实现了自定义的序列化和反序列化方法。在序列化方法中，我们将名称长度编码为一个字节，然后将名称和年龄编码为字节数组。在反序列化方法中，我们首先读取名称长度字节，然后读取名称和年龄字节，并将它们解码为一个Person结构体。

自定义大小端序列化和反序列化#

1
use bincode::{serialize, deserialize, Error, ErrorKind};
2
use std::io::{Cursor, Write, Read};
3

4
#[derive(Debug, PartialEq)]
5
struct Person {
6
    name: String,
7
    age: u8,
8
}
9

10
impl Person {
11
    fn serialize<W: Write>(&self, writer: &mut W, big_endian: bool) -> Result<(), Error> {
12
        let name_bytes = self.name.as_bytes();
13
        if name_bytes.len() > 255 {
14
            return Err(Error::new(ErrorKind::Custom("name too long".to_string())));
15
        }
16
        let mut name_len_bytes = [0; 1];
17
        name_len_bytes[0] = name_bytes.len() as u8;
18
        if big_endian {
19
            writer.write_all(&name_len_bytes[..].reverse())?;
20
        } else {
21
            writer.write_all(&name_len_bytes[..])?;
22
        }
23
        writer.write_all(name_bytes)?;
24
        writer.write_all(&self.age.to_le_bytes())?;
25
        Ok(())
26
    }
27

28
    fn deserialize<R: Read>(reader: &mut R, big_endian: bool) -> Result<Self, Error> {
29
        let mut name_len_bytes = [0; 1];
30
        reader.read_exact(&mut name_len_bytes)?;
31
        let name_len = if big_endian {
32
            u8::from_be_bytes(name_len_bytes)
33
        } else {
34
            u8::from_le_bytes(name_len_bytes)
35
        } as usize;
36
        let mut name_bytes = vec![0; name_len];
37
        reader.read_exact(&mut name_bytes)?;
38
        let name = String::from_utf8(name_bytes)?;
39
        let mut age_bytes = [0; 1];
40
        reader.read_exact(&mut age_bytes)?;
41
        let age = age_bytes[0];
42
        Ok(Person { name, age })
43
    }
44
}
45

46
fn main() {
47
    let person = Person {
48
        name: "Alice".to_string(),
49
        age: 25,
50
    };
51

52
    // Serialize
53
    let mut buffer = Cursor::new(Vec::new());
54
    person.serialize(&mut buffer, true).unwrap();
55
    let encoded = buffer.into_inner();
56

57
    // Deserialize
58
    let mut cursor = Cursor::new(encoded);
59
    let decoded: Person = Person::deserialize(&mut cursor, true).unwrap();
60

61
    assert_eq!(person, decoded);
62
}

在这个示例中，我们定义了一个Person结构体，并实现了自定义的大小端序列化和反序列化方法。在序列化方法中，我们将名称长度编码为一个字节，并根据big_endian参数决定字节序。在反序列化方法中，我们首先读取名称长度字节，并根据big_endian参数解码字节序。然后，我们读取名称和年龄字节，并将它们解码为一个Person结构体。

序列化和反序列化一个动态数组#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Person {
5
    name: String,
6
    age: u8,
7
}
8

9
fn main() {
10
    let people = vec![
11
        Person {
12
            name: "Alice".to_string(),
13
            age: 25,
14
        },
15
        Person {
16
            name: "Bob".to_string(),
17
            age: 30,
18
        },
19
        Person {
20
            name: "Charlie".to_string(),
21
            age: 35,
22
        },
23
    ];
24

25
    // Serialize
26
    let encoded: Vec<u8> = serialize(&people).unwrap();
27

28
    // Deserialize
29
    let decoded: Vec<Person> = deserialize(&encoded[..]).unwrap();
30

31
    assert_eq!(people, decoded);
32
}

在这个示例中，我们定义了一个包含Person结构体的动态数组。我们将其序列化为一个字节数组，然后将其反序列化回一个Person结构体的动态数组，并将其与原始数组进行比较。

序列化和反序列化一个结构体的子集#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Person {
5
    name: String,
6
    age: u8,
7
    address: String,
8
}
9

10
#[derive(Serialize, Deserialize, Debug, PartialEq)]
11
struct PersonSubset {
12
    name: String,
13
    age: u8,
14
}
15

16
fn main() {
17
    let person = Person {
18
        name: "Alice".to_string(),
19
        age: 25,
20
        address: "123 Main St".to_string(),
21
    };
22

23
    // Serialize subset
24
    let encoded: Vec<u8> = serialize(&PersonSubset {
25
        name: person.name.clone(),
26
        age: person.age,
27
    })
28
    .unwrap();
29

30
    // Deserialize subset
31
    let decoded: PersonSubset = deserialize(&encoded[..]).unwrap();
32

33
    assert_eq!(
34
        decoded,
35
        PersonSubset {
36
            name: "Alice".to_string(),
37
            age: 25
38
        }
39
    );
40

41
    // Deserialize full struct from subset bytes
42
    let decoded_full: Person = deserialize(&encoded[..]).unwrap();
43
    assert_eq!(
44
        decoded_full,
45
        Person {
46
            name: "Alice".to_string(),
47
            age: 25,
48
            address: "".to_string()
49
        }
50
    );
51

52
    // Serialize full struct to subset bytes
53
    let encoded_subset: Vec<u8> = serialize(&PersonSubset {
54
        name: person.name.clone(),
55
        age: person.age,
56
    })
57
    .unwrap();
58
    assert_eq!(encoded, encoded_subset);
59
}

在这个示例中，我们定义了一个Person结构体，它有一个name字段、一个age字段和一个address字段。我们将其序列化为一个字节数组，然后将其反序列化回一个PersonSubset结构体的字节数组，该结构体只包含name和age字段。我们还演示了如何从子集字节数组反序列化回完整的结构体，以及如何将完整的结构体序列化为子集字节数组。

使用自定义配置#

在某些情况下，您可能需要使用自定义配置来序列化和反序列化数据。例如，您可能需要使用大端字节序而不是默认的小端字节序。您可以使用bincode::config()函数创建一个默认配置，然后使用bincode::serialize_with()和bincode::deserialize_from()函数序列化和反序列化数据。例如：

1
use bincode::{serialize_with, deserialize_from, config};
2
use std::io::{Cursor, Write};
3

4
let person = Person {
5
    name: "Alice".to_string(),
6
    age: 25,
7
};
8

9
// Serialize with big endian byte order
10
let mut buffer = Cursor::new(Vec::new());
11
serialize_with(&mut buffer, &person, config().big_endian()).unwrap();
12
let encoded = buffer.into_inner();
13

14
// Deserialize with big endian byte order
15
let mut cursor = Cursor::new(encoded);
16
let decoded: Person = deserialize_from(&mut cursor, config().big_endian()).unwrap();

优化序列化和反序列化性能#

为了优化序列化和反序列化性能，可以使用bincode::config模块中的DefaultOptions和Options结构体，调整序列化和反序列化的选项。以下是一个优化性能的示例：

1
use bincode::{serialize_with_options, deserialize_with_options, DefaultOptions};
2

3
// 优化性能
4
let mut options = DefaultOptions::new();
5
options.limit = bincode::Bounded(1024); // 限制序列化和反序列化的最大字节数
6
let data = vec![0; 1024 * 1024 * 1024]; // 1GB数据
7

8
// 序列化大数据量
9
let encoded: Vec<u8> = serialize_with_options(&data, options).unwrap();
10

11
// 反序列化大数据量
12
let decoded: Vec<u8> = deserialize_with_options(&encoded[..], options).unwrap();

处理序列化和反序列化错误#

在序列化和反序列化过程中，可能会出现错误。为了处理这些错误，可以使用Result类型和bincode::Error枚举类型。以下是一个处理错误的示例：

1
use bincode::{serialize, deserialize, Error};
2

3
// 处理错误
4
let num = "abc";
5
let encoded: Result<Vec<u8>, Error> = serialize(&num);
6
match encoded {
7
    Ok(v) => println!("Encoded: {:?}", v),
8
    Err(e) => println!("Error: {:?}", e),
9
}
10

11
let encoded = vec![1, 2, 3];
12
let decoded: Result<String, Error> = deserialize(&encoded[..]);
13
match decoded {
14
    Ok(v) => println!("Decoded: {:?}", v),
15
    Err(e) => println!("Error: {:?}", e),
16
}

总结#

Bincode 是 Rust 语言中的一个二进制编码库，可以将 Rust 的数据结构序列化为二进制格式，以便于存储和传输。使用 Bincode 可以方便地将数据序列化为二进制格式，也可以反序列化二进制数据为 Rust 数据结构。Bincode 支持大部分 Rust 的数据类型，包括基本类型、结构体、枚举、数组、元组等。在序列化和反序列化过程中，Bincode 会自动进行类型检查和字节对齐，保证数据的正确性和兼容性。同时，Bincode 还支持自定义序列化和反序列化方法，以满足特殊需求。为了优化序列化和反序列化性能，可以使用bincode::config模块中的DefaultOptions和Options结构体，调整序列化和反序列化的选项。在序列化和反序列化过程中，可能会出现错误，可以使用Result类型和bincode::Error枚举类型来处理这些错误。

音乐

音乐