以下の内容はhttps://syu-m-5151.hatenablog.com/entry/2024/11/26/141035より取得しました。

RustでJSONを扱いたいのでSerde入門します

Rust

はじめに

Rustでデータのシリアライズ/デシリアライズを扱う際、最も広く使われているのがserdeクレートです。特にWeb APIやファイル入出力でよく使用されるJSONとの相互変換において、非常に重宝するツールです。今回は、serdeの基本的な使い方と、開発効率を上げるためのツールについて解説します。

Serdeとは

Serdeは"Serialize"と"Deserialize"を組み合わせた造語で、データ構造の変換を担当するRustのフレームワークです。

  • 多様なデータフォーマットに対応（JSON、YAML(アーカイブされている)、TOML等）
  • 高性能で型安全な実装
  • カスタマイズ可能な属性システム
  • コード生成による簡単な実装

docs.rs

プロジェクトのセットアップ

まず、Cargo.tomlに必要な依存関係を追加します。

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

基本的な使い方

1. 構造体の定義

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct User {
    name: String,
    age: u32,
    email: String,
    is_active: bool,
}

2. JSONからRustへの変換（デシリアライズ）

fn main() {
    let json_str = r#"
    {
        "name": "John Doe",
        "age": 30,
        "email": "john@example.com",
        "is_active": true
    }
    "#;

    let user: User = serde_json::from_str(json_str).unwrap();
    println!("Deserialized user: {:?}", user);
}

3. RustからJSONへの変換（シリアライズ）

fn main() {
    let user = User {
        name: "Jane Doe".to_string(),
        age: 25,
        email: "jane@example.com".to_string(),
        is_active: true,
    };

    let json = serde_json::to_string_pretty(&user).unwrap();
    println!("Serialized JSON:\n{}", json);
}

JSON to Rust ツールの活用

開発効率を大幅に向上させるツールとして、「JSON to Rust」があります。このツールは、JSONデータからRustの構造体定義を自動生成してくれます。

JSON to Rustの使い方

  1. https://jsonformatter.org/json-to-rust にアクセス
  2. 左側のペインにJSONデータを貼り付け
  3. 自動的に右側にRustの構造体定義が生成される

例えば、以下のようなJSONデータがあった場合

{
    "user_profile": {
        "id": 123,
        "username": "rust_lover",
        "settings": {
            "theme": "dark",
            "notifications": true
        },
        "tags": ["rust", "programming"]
    }
}

以下のようなRust構造体が生成されます。

// Example code that deserializes and serializes the model.
// extern crate serde;
// #[macro_use]
// extern crate serde_derive;
// extern crate serde_json;
//
// use generated_module::[object Object];
//
// fn main() {
//     let json = r#"{"answer": 42}"#;
//     let model: [object Object] = serde_json::from_str(&json).unwrap();
// }

extern crate serde_derive;

#[derive(Serialize, Deserialize)]
pub struct Welcome3 {
    #[serde(rename = "user_profile")]
    user_profile: UserProfile,
}

#[derive(Serialize, Deserialize)]
pub struct UserProfile {
    #[serde(rename = "id")]
    id: i64,

    #[serde(rename = "username")]
    username: String,

    #[serde(rename = "settings")]
    settings: Settings,

    #[serde(rename = "tags")]
    tags: Vec<String>,
}

#[derive(Serialize, Deserialize)]
pub struct Settings {
    #[serde(rename = "theme")]
    theme: String,

    #[serde(rename = "notifications")]
    notifications: bool,
}

高度な使い方

カスタム属性の活用

Serdeは様々な属性を提供して、シリアライズ/デシリアライズの挙動をカスタマイズできます。

#[derive(Serialize, Deserialize, Debug)]
struct Configuration {
    #[serde(rename = "apiKey")]
    api_key: String,
    
    #[serde(default)]
    timeout_seconds: u32,
    
    #[serde(skip_serializing_if = "Option::is_none")]
    optional_field: Option<String>,
}

エラーハンドリング

実際のアプリケーションでは、適切なエラーハンドリングが重要です。

use serde::{Serialize, Deserialize};
use std::error::Error;
use std::fs;
use std::io;
use std::collections::HashMap;

// ユーザーの基本構造体
#[derive(Serialize, Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    age: u32,
    email: String,
    is_active: bool,
    // オプショナルなフィールド
    #[serde(skip_serializing_if = "Option::is_none")]
    metadata: Option<HashMap<String, String>>,
}

// カスタムエラー型の定義
#[derive(Debug)]
enum UserError {
    ParseError(serde_json::Error),    // JSONパースエラー
    ValidationError(String),          // バリデーションエラー
    DatabaseError(String),            // DB操作エラー
    IoError(io::Error),              // ファイル操作エラー
}

// serde_json::ErrorからUserErrorへの変換を実装
impl From<serde_json::Error> for UserError {
    fn from(err: serde_json::Error) -> UserError {
        UserError::ParseError(err)
    }
}

// io::ErrorからUserErrorへの変換を実装
impl From<io::Error> for UserError {
    fn from(err: io::Error) -> UserError {
        UserError::IoError(err)
    }
}

// std::error::Errorトレイトの実装
impl std::fmt::Display for UserError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            UserError::ParseError(e) => write!(f, "Parse error: {}", e),
            UserError::ValidationError(msg) => write!(f, "Validation error: {}", msg),
            UserError::DatabaseError(msg) => write!(f, "Database error: {}", msg),
            UserError::IoError(e) => write!(f, "IO error: {}", e),
        }
    }
}

impl Error for UserError {}

// Userの実装
impl User {
    // バリデーションメソッド
    fn validate(&self) -> Result<(), UserError> {
        if self.name.is_empty() {
            return Err(UserError::ValidationError("Name cannot be empty".to_string()));
        }
        if self.age > 150 {
            return Err(UserError::ValidationError("Invalid age".to_string()));
        }
        if !self.email.contains('@') {
            return Err(UserError::ValidationError("Invalid email format".to_string()));
        }
        Ok(())
    }
}

// 基本的なJSONパース関数
fn parse_user(json_str: &str) -> Result<User, serde_json::Error> {
    // map_errを使用してエラーをログ出力
    serde_json::from_str(json_str).map_err(|e| {
        println!("Error parsing JSON: {}", e);
        e  // 元のエラーを返す
    })
}

// より詳細なエラーハンドリングを行う関数
fn process_user_data(json_str: &str) -> Result<User, UserError> {
    // JSONのパース
    let user: User = serde_json::from_str(json_str)?;  // ?演算子でエラーを伝播
    
    // バリデーション
    user.validate()?;  // ?演算子でエラーを伝播
    
    Ok(user)
}

// 複数ユーザーからの検索（Option型との組み合わせ）
fn find_user_by_id(json_str: &str, target_id: u32) -> Result<Option<User>, UserError> {
    // JSONから複数ユーザーをパース
    let users: Vec<User> = serde_json::from_str(json_str)?;
    
    // 指定されたIDのユーザーを探す
    Ok(users.into_iter().find(|user| user.id == target_id))
}

// ファイル操作を含むエラーハンドリング
fn load_user_from_file(path: &str) -> Result<User, UserError> {
    // ファイルを読み込み
    let content = fs::read_to_string(path).map_err(|e| {
        eprintln!("Failed to read file {}: {}", path, e);
        UserError::IoError(e)
    })?;

    // JSONをパースしてUserを返す
    process_user_data(&content)
}

// ファイルへの保存
fn save_user_to_file(user: &User, path: &str) -> Result<(), UserError> {
    // UserをJSONに変換
    let json = serde_json::to_string_pretty(user).map_err(|e| {
        eprintln!("Failed to serialize user: {}", e);
        UserError::ParseError(e)
    })?;

    // ファイルに書き込み
    fs::write(path, json).map_err(|e| {
        eprintln!("Failed to write to file {}: {}", path, e);
        UserError::IoError(e)
    })?;

    Ok(())
}

fn main() {
    // 1. 有効なJSONの例
    let valid_json = r#"
        {
            "id": 1,
            "name": "John Doe",
            "age": 30,
            "email": "john@example.com",
            "is_active": true,
            "metadata": {
                "last_login": "2024-01-01",
                "location": "Tokyo"
            }
        }
    "#;

    // 2. 無効なJSONの例（バリデーションエラー）
    let invalid_json = r#"
        {
            "id": 2,
            "name": "",
            "age": 200,
            "email": "invalid-email",
            "is_active": true
        }
    "#;

    // 3. 複数ユーザーのJSONの例
    let users_json = r#"[
        {
            "id": 1,
            "name": "John Doe",
            "age": 30,
            "email": "john@example.com",
            "is_active": true
        },
        {
            "id": 2,
            "name": "Jane Doe",
            "age": 25,
            "email": "jane@example.com",
            "is_active": true
        }
    ]"#;

    // 4. 各種エラーハンドリングの実演
    println!("1. 基本的なパース:");
    match parse_user(valid_json) {
        Ok(user) => println!("成功: {:?}", user),
        Err(e) => println!("エラー: {}", e),
    }

    println!("\n2. バリデーション付きパース:");
    match process_user_data(invalid_json) {
        Ok(user) => println!("成功: {:?}", user),
        Err(e) => println!("エラー: {}", e),
    }

    println!("\n3. ユーザー検索:");
    match find_user_by_id(users_json, 1) {
        Ok(Some(user)) => println!("ユーザーが見つかりました: {:?}", user),
        Ok(None) => println!("ユーザーが見つかりません"),
        Err(e) => println!("エラー: {}", e),
    }

    println!("\n4. ファイル操作:");
    // 有効なユーザーをファイルに保存
    if let Ok(user) = parse_user(valid_json) {
        match save_user_to_file(&user, "user.json") {
            Ok(()) => println!("ユーザーを保存しました"),
            Err(e) => println!("保存エラー: {}", e),
        }

        // 保存したファイルから読み込み
        match load_user_from_file("user.json") {
            Ok(loaded_user) => println!("ロードしたユーザー: {:?}", loaded_user),
            Err(e) => println!("ロードエラー: {}", e),
        }
    }
}

ベストプラクティス

  1. 型の使い分け

    • 必須フィールドは通常の型
    • オプショナルフィールドはOption<T>
    • 配列はVec<T>を使用

  2. エラーハンドリング

    • unwrap()は開発時のみ使用
    • 本番コードではResultを適切に処理

  3. カスタム属性の活用

    • #[serde(rename)]でフィールド名の変換
    • #[serde(default)]でデフォルト値の設定
    • #[serde(skip_serializing_if)]で条件付きスキップ

まず、Cargo.tomlにchronoの依存関係を追加します。

use chrono;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::error::Error as StdError;
use std::fmt;
use std::fs; // chronoクレートのインポート

// ベストプラクティスに基づいた構造体の定義
#[derive(Serialize, Deserialize, Debug)]
struct UserProfile {
    // 1. 必須フィールド（通常の型）
    id: u64,
    username: String,
    email: String,

    // 2. オプショナルフィールド（Option<T>の使用）
    #[serde(skip_serializing_if = "Option::is_none")]
    phone_number: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    biography: Option<String>,

    // 3. 配列（Vec<T>の使用）
    #[serde(skip_serializing_if = "Vec::is_empty")]
    interests: Vec<String>,

    // 4. カスタム属性の活用
    // JSONでは"lastLoginTime"として表示
    #[serde(rename = "lastLoginTime")]
    last_login_time: String,

    // デフォルト値の設定
    #[serde(default)]
    is_active: bool,

    // 動的なキーバリューペア
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    metadata: HashMap<String, String>,
}

// カスタムエラー型の定義
#[derive(Debug)]
enum ProfileError {
    JsonError(serde_json::Error),
    ValidationError(String),
    IoError(std::io::Error),
}

// ProfileErrorにDisplayトレイトを実装
impl fmt::Display for ProfileError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ProfileError::JsonError(e) => write!(f, "JSON error: {}", e),
            ProfileError::ValidationError(e) => write!(f, "Validation error: {}", e),
            ProfileError::IoError(e) => write!(f, "IO error: {}", e),
        }
    }
}

// ProfileErrorにErrorトレイトを実装
impl StdError for ProfileError {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            ProfileError::JsonError(e) => Some(e),
            ProfileError::ValidationError(_) => None,
            ProfileError::IoError(e) => Some(e),
        }
    }
}

// エラー変換の実装
impl From<serde_json::Error> for ProfileError {
    fn from(err: serde_json::Error) -> Self {
        ProfileError::JsonError(err)
    }
}

impl From<std::io::Error> for ProfileError {
    fn from(err: std::io::Error) -> Self {
        ProfileError::IoError(err)
    }
}

// UserProfileの実装
impl UserProfile {
    // コンストラクタ
    fn new(id: u64, username: String, email: String) -> Self {
        UserProfile {
            id,
            username,
            email,
            phone_number: None,
            biography: None,
            interests: Vec::new(),
            last_login_time: chrono::Utc::now().to_rfc3339(),
            is_active: true,
            metadata: HashMap::new(),
        }
    }

    // バリデーション
    fn validate(&self) -> Result<(), ProfileError> {
        if self.username.is_empty() {
            return Err(ProfileError::ValidationError(
                "Username cannot be empty".to_string(),
            ));
        }
        if !self.email.contains('@') {
            return Err(ProfileError::ValidationError(
                "Invalid email format".to_string(),
            ));
        }
        Ok(())
    }

    // メタデータの追加
    fn add_metadata(&mut self, key: &str, value: &str) {
        self.metadata.insert(key.to_string(), value.to_string());
    }

    // 興味・関心の追加
    fn add_interest(&mut self, interest: &str) {
        self.interests.push(interest.to_string());
    }
}

// プロファイル処理関数
fn process_profile(json_str: &str) -> Result<UserProfile, ProfileError> {
    // JSONからプロファイルを作成
    let profile: UserProfile = serde_json::from_str(json_str)?;

    // バリデーション
    profile.validate()?;

    Ok(profile)
}

// ファイル操作を含むプロファイル保存
fn save_profile(profile: &UserProfile, path: &str) -> Result<(), ProfileError> {
    // バリデーション
    profile.validate()?;

    // JSON文字列に変換（整形付き）
    let json = serde_json::to_string_pretty(profile)?;

    // ファイルに保存
    fs::write(path, json)?;

    Ok(())
}

fn main() -> Result<(), Box<dyn StdError>> {
    // 1. プロファイルの作成
    let mut profile = UserProfile::new(1, "john_doe".to_string(), "john@example.com".to_string());

    // オプショナルフィールドの設定
    profile.phone_number = Some("123-456-7890".to_string());
    profile.biography = Some("Tech enthusiast and developer".to_string());

    // 興味・関心の追加
    profile.add_interest("Programming");
    profile.add_interest("Open Source");

    // メタデータの追加
    profile.add_metadata("location", "Tokyo");
    profile.add_metadata("timezone", "UTC+9");

    // 2. JSONへの変換と保存
    println!("保存するプロファイル:");
    println!("{:#?}", profile);

    save_profile(&profile, "profile.json").map_err(|e| Box::new(e) as Box<dyn StdError>)?;
    println!("\nプロファイルを保存しました");

    // 3. JSONからの読み込みとバリデーション
    let json_str = r#"{
        "id": 2,
        "username": "jane_doe",
        "email": "jane@example.com",
        "phone_number": "098-765-4321",
        "biography": "Software Engineer",
        "interests": ["AI", "Machine Learning"],
        "lastLoginTime": "2024-01-01T00:00:00Z",
        "metadata": {
            "location": "Osaka",
            "language": "ja"
        }
    }"#;

    match process_profile(json_str) {
        Ok(loaded_profile) => {
            println!("\n読み込んだプロファイル:");
            println!("{:#?}", loaded_profile);
        }
        Err(e) => match e {
            ProfileError::JsonError(e) => println!("JSONエラー: {}", e),
            ProfileError::ValidationError(e) => println!("バリデーションエラー: {}", e),
            ProfileError::IoError(e) => println!("I/Oエラー: {}", e),
        },
    }

    // 4. 無効なデータの例
    let invalid_json = r#"{
        "id": 3,
        "username": "",
        "email": "invalid-email"
    }"#;

    match process_profile(invalid_json) {
        Ok(_) => println!("予期せぬ成功"),
        Err(e) => match e {
            ProfileError::ValidationError(msg) => {
                println!("\nバリデーションエラー（期待通り）: {}", msg)
            }
            _ => println!("予期せぬエラー"),
        },
    }

    Ok(())
}

まとめ

Serdeは、RustでJSONを扱う際の強力なツールです。JSON to Rustのようなツールと組み合わせることで、より効率的な開発が可能になります。基本的な使い方を押さえた上で、プロジェクトの要件に応じて高度な機能を活用していくことをお勧めします。

参考リンク



以上の内容はhttps://syu-m-5151.hatenablog.com/entry/2024/11/26/141035より取得しました。
このページはhttp://font.textar.tv/のウェブフォントを使用してます
不具合報告/要望等はこちらへお願いします。
モバイルやる夫Viewer Ver0.14