JSON 转 Rust

用 Actix-web 4.x 把生成的 struct 作为 web::Json<T> 参数，HTTP POST 请求体自动反序列化。

// Cargo.toml
// [dependencies]
// actix-web = "4"
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use serde::{Deserialize, Serialize};

// 由本工具自动生成（from JSON）
#[derive(Serialize, Deserialize, Debug)]
pub struct CreateUserRequest {
    name: String,
    email: String,
    age: i64,
    tags: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: i64,
    name: String,
    email: String,
    age: i64,
    tags: Vec<String>,
}

// Actix-web handler：JSON 入参自动反序列化
async fn create_user(payload: web::Json<CreateUserRequest>) -> impl Responder {
    let req = payload.into_inner();
    let user = User {
        id: 1,
        name: req.name,
        email: req.email,
        age: req.age,
        tags: req.tags,
    };
    HttpResponse::Ok().json(user) // 响应也用 serde_json 序列化
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/users", web::post().to(create_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

/*
 * 客户端调用：
 * curl -X POST http://127.0.0.1:8080/users \
 *   -H "Content-Type: application/json" \
 *   -d '{"name":"Alice","email":"alice@example.com","age":30,"tags":["rust","actix"]}'
 */

axum 服务端用 Json<T> extractor，reqwest 客户端用 .json::<T>() 反序列化响应，生成的 struct 双向兼容。

// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
// reqwest = { version = "0.12", features = ["json"] }

use axum::{routing::get, Json, Router};
use serde::{Deserialize, Serialize};

// 由本工具自动生成
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Address {
    city: String,
    zip: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct User {
    id: i64,
    name: String,
    email: String,
    address: Address,
    tags: Vec<String>,
}

// axum handler：返回 JSON 响应
async fn get_user() -> Json<User> {
    Json(User {
        id: 1,
        name: "Alice".into(),
        email: "alice@example.com".into(),
        address: Address { city: "Beijing".into(), zip: "100000".into() },
        tags: vec!["rust".into(), "axum".into()],
    })
}

// reqwest 客户端：反序列化远程 API 响应
async fn fetch_user(url: &str) -> Result<User, reqwest::Error> {
    let user: User = reqwest::get(url).await?.json().await?;
    Ok(user)
}

#[tokio::main]
async fn main() {
    // 启动 axum 服务
    let app = Router::new().route("/user", get(get_user));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

/*
 * 编译后访问：
 * curl http://127.0.0.1:8080/user
 * {"id":1,"name":"Alice","email":"alice@example.com",
 *  "address":{"city":"Beijing","zip":"100000"},
 *  "tags":["rust","axum"]}
 */

当 JSON 字段为 snake_case 而 Rust 字段想用 camelCase 时，通过 #[serde(rename)] 显式映射，并替换语义类型为 chrono::DateTime。

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
pub struct Article {
    #[serde(rename = "article_id")]
    pub article_id: i64,

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

    // JSON: "2026-07-08T10:00:00Z" → chrono::DateTime<Utc>
    #[serde(rename = "created_at")]
    pub created_at: DateTime<Utc>,

    #[serde(rename = "view_count")]
    pub view_count: i64,

    // 缺失字段使用 Default::default()
    #[serde(rename = "summary", default)]
    pub summary: Option<String>,

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

fn main() -> Result<(), serde_json::Error> {
    let json = r#"{
        "article_id": 42,
        "title": "Hello Rust",
        "created_at": "2026-07-08T10:00:00Z",
        "view_count": 1024,
        "tags": ["rust", "serde"]
    }"#;

    let article: Article = serde_json::from_str(json)?;
    println!("{:?}", article);
    // Article { article_id: 42, title: "Hello Rust",
    //   created_at: 2026-07-08T10:00:00Z, view_count: 1024, ... }

    // 反向序列化：Rust 值 → JSON 字符串
    let s = serde_json::to_string(&article)?;
    println!("{}", s);
    Ok(())
}

/*
 * Cargo.toml 依赖：
 * serde = { version = "1", features = ["derive"] }
 * serde_json = "1"
 * chrono = { version = "0.4", features = ["serde"] }
 */

把生成的 struct 作为 Tauri #[tauri::command] 的入参类型，前端 invoke 时按 JSON 自动反序列化。

// Cargo.toml
// [dependencies]
// tauri = { version = "2", features = [] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

use serde::{Deserialize, Serialize};

// 由本工具自动生成
#[derive(Serialize, Deserialize, Debug)]
pub struct CreateNoteRequest {
    pub title: String,
    pub content: String,
    pub tags: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Note {
    pub id: i64,
    pub title: String,
    pub content: String,
    pub tags: Vec<String>,
    pub created_at: String, // 可手动改为 chrono::DateTime<Utc>
}

// Tauri command：前端通过 invoke('create_note', payload) 调用
#[tauri::command]
fn create_note(payload: CreateNoteRequest) -> Result<Note, String> {
    let note = Note {
        id: 1,
        title: payload.title,
        content: payload.content,
        tags: payload.tags,
        created_at: "2026-07-14T10:00:00Z".to_string(),
    };
    Ok(note)
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![create_note])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

/*
 * 前端调用示例 (TypeScript):
 *
 * import { invoke } from '@tauri-apps/api/core';
 * const note = await invoke<Note>('create_note', {
 *   payload: { title: 'Hello', content: 'World', tags: ['rust', 'tauri'] }
 * });
 */