以下是关于Rust字节大小处理库bytesize-serde的使用内容，支持Serde序列化与反序列化的字节单位转换工具：

使用说明

bytesize-serde是基于bytesize crate的替代serde实现，它利用FromStr实现进行人类可读的序列化和反序列化。

示例代码

use bytesize::ByteSize;
use serde::{Serialize, Deserialize};

fn main() {
    #[derive(Serialize, Deserialize)]
    struct T {
        #[serde(with = "bytesize_serde")]  // 使用bytesize_serde进行序列化和反序列化
        x: ByteSize,
    }

    let t: T = serde_json::from_str(r#"{ "x": "5 MB" }"#).unwrap();  // 从JSON字符串反序列化
    assert_eq!(t.x, "5 MB".parse::<ByteSize>().unwrap());  // 验证反序列化结果
}

完整示例

use bytesize::ByteSize;
use serde::{Serialize, Deserialize};
use serde_json;

#[derive(Debug, Serialize, Deserialize)]
struct Config {
    #[serde(with = "bytesize_serde")]
    memory_limit: ByteSize,
    #[serde(with = "bytesize_serde")]
    cache_size: ByteSize,
}

fn main() {
    // 序列化示例
    let config = Config {
        memory_limit: ByteSize::mb(512),
        cache_size: ByteSize::gb(1),
    };
    
    let json = serde_json::to_string(&config).unwrap();
    println!("Serialized config: {}", json);
    // 输出: {"memory_limit":"512 MB","cache_size":"1 GB"}

    // 反序列化示例
    let json_input = r#"{
        "memory_limit": "256 MB",
        "cache_size": "2 GB"
    }"#;
    
    let config: Config = serde_json::from_str(json_input).unwrap();
    println!("Deserialized config: {:?}", config);
    // 输出: Config { memory_limit: 256MB, cache_size: 2GB }
}

安装

在项目目录中运行以下Cargo命令：

cargo add bytesize-serde

或者在Cargo.toml中添加：

bytesize-serde = "0.2.1"

完整示例demo

use bytesize::ByteSize;
use serde::{Serialize, Deserialize};
use serde_json;

// 定义配置结构体
#[derive(Debug, Serialize, Deserialize)]
struct SystemConfig {
    #[serde(with = "bytesize_serde")]
    heap_size: ByteSize,
    
    #[serde(with = "bytesize_serde")]
    max_file_size: ByteSize,
    
    #[serde(with = "bytesize_serde")]
    download_buffer: ByteSize,
}

fn main() {
    // 创建配置实例
    let config = SystemConfig {
        heap_size: ByteSize::gb(4),
        max_file_size: ByteSize::mb(100),
        download_buffer: ByteSize::kb(512),
    };

    // 序列化为JSON字符串
    let json_str = serde_json::to_string_pretty(&config).unwrap();
    println!("系统配置(JSON):\n{}", json_str);
    /* 输出:
    {
      "heap_size": "4 GB",
      "max_file_size": "100 MB",
      "download_buffer": "512 KB"
    }
    */

    // 从JSON字符串反序列化
    let json_input = r#"{
        "heap_size": "8 GB",
        "max_file_size": "200 MB",
        "download_buffer": "1 MB"
    }"#;
    
    let parsed_config: SystemConfig = serde_json::from_str(json_input).unwrap();
    println!("\n解析后的配置: {:?}", parsed_config);
    /* 输出:
    解析后的配置: SystemConfig { 
        heap_size: 8GB, 
        max_file_size: 200MB, 
        download_buffer: 1MB 
    }
    */
}

sinazl 1楼

Rust字节大小处理库bytesize-serde使用指南

bytesize-serde是一个Rust库，它扩展了bytesize库的功能，添加了对Serde序列化和反序列化的支持，使得处理字节大小单位转换更加方便。

功能特点

支持常见的字节大小单位(B, KB, MB, GB, TB, PB, EB)
与Serde框架无缝集成
支持从字符串和数字进行序列化/反序列化
提供人性化的显示格式

安装

在Cargo.toml中添加依赖：

[dependencies]
bytesize = "1.2"
bytesize-serde = "0.1"
serde = { version = "1.0", features = ["derive"] }

基本使用方法

完整示例代码

use serde::{Serialize, Deserialize};
use bytesize::ByteSize;

// 基本配置结构体示例
#[derive(Debug, Serialize, Deserialize)]
struct SystemConfig {
    #[serde(with = "bytesize_serde")]
    heap_size: ByteSize,
    
    #[serde(with = "bytesize_serde")]
    cache_size: ByteSize,
}

// 可选配置结构体示例
#[derive(Debug, Serialize, Deserialize)]
struct OptionalConfig {
    #[serde(with = "bytesize_serde::option")]
    max_memory: Option<ByteSize>,
}

// 带默认值的配置结构体示例
#[derive(Debug, Serialize, Deserialize)]
struct AppConfig {
    name: String,
    #[serde(default = "default_storage")]
    #[serde(with = "bytesize_serde")]
    storage: ByteSize,
}

fn default_storage() -> ByteSize {
    ByteSize::gb(10) // 默认10GB
}

fn main() {
    // 示例1: 基本序列化和反序列化
    let config = SystemConfig {
        heap_size: ByteSize::mb(256),
        cache_size: ByteSize::gb(2),
    };
    
    // 序列化为JSON
    let json = serde_json::to_string_pretty(&config).unwrap();
    println!("序列化结果:\n{}", json);
    
    // 从JSON反序列化
    let json_str = r#"
    {
        "heap_size": "512MB",
        "cache_size": "4GB"
    }"#;
    let decoded: SystemConfig = serde_json::from_str(json_str).unwrap();
    println!("反序列化结果: {:?}", decoded);
    
    // 示例2: 可选字段处理
    let opt_config = OptionalConfig {
        max_memory: Some(ByteSize::gb(8)),
    };
    let opt_json = serde_json::to_string_pretty(&opt_config).unwrap();
    println!("\n可选字段序列化:\n{}", opt_json);
    
    // 从缺失字段的JSON反序列化
    let empty_json = r#"{}"#;
    let empty_config: OptionalConfig = serde_json::from_str(empty_json).unwrap();
    println!("缺失字段反序列化: {:?}", empty_config);
    
    // 示例3: 默认值处理
    let partial_config: AppConfig = serde_json::from_str(r#"{ "name": "my-app" }"#).unwrap();
    println!("\n使用默认值的配置: {:?}", partial_config);
    
    let full_config: AppConfig = serde_json::from_str(r#"
    {
        "name": "large-app",
        "storage": "50GB"
    }"#).unwrap();
    println!("完整配置: {:?}", full_config);
    
    // 示例4: 支持多种输入格式
    #[derive(Debug, Deserialize)]
    struct SizeTest {
        #[serde(with = "bytesize_serde")]
        size: ByteSize,
    }
    
    let num_input: SizeTest = serde_json::from_str(r#"{ "size": 1048576 }"#).unwrap();
    println!("\n数字输入: {:?}", num_input.size); // 1MB
    
    let str_input: SizeTest = serde_json::from_str(r#"{ "size": "2.5GB" }"#).unwrap();
    println!("字符串输入: {:?}", str_input.size); // 2.5GB
    
    let lower_input: SizeTest = serde_json::from_str(r#"{ "size": "500mb" }"#).unwrap();
    println!("小写单位输入: {:?}", lower_input.size); // 500MB
}

注意事项

输入字符串不区分大小写，"1gb"和"1GB"都是有效的
数字输入会被解释为字节数
浮点数值也是支持的，如"1.5GB"
确保在反序列化时使用有效的单位(B, KB, MB, GB, TB, PB, EB)

bytesize-serde是处理配置文件、API响应等场景中字节大小单位的理想选择，它提供了简洁的语法和强大的功能。

Rust字节大小处理库bytesize-serde的使用，支持Serde序列化与反序列化的字节单位转换工具