Struct JwtConfig 

pub struct JwtConfig {
    pub secret: String,
    pub expire_days: i64,
}

JWT配置结构

Fields

secret: String

JWT密钥

expire_days: i64

过期时间（天数）

Implementations

impl JwtConfig

pub fn new(secret: impl Into<String>, expire_days: i64) -> Self

创建新的JWT配置

Examples found in repository

examples/jwt_usage.rs (line 73)

fn example_custom_config() -> Result<()> {
    println!("2. 使用自定义配置:");

    // 创建自定义配置
    let config = JwtConfig::new("my_super_secret_key_2024", 30); // 30天过期
    let jwt_manager = JwtManager::new(config);

    let session_data = SessionData {
        user_id: "user456".to_string(),
        permissions: vec!["read".to_string(), "write".to_string(), "admin".to_string()],
        login_time: chrono::Utc::now().timestamp(),
    };

    // 使用自定义配置生成token
    let token = jwt_manager.generate_token(&session_data)?;
    println!("   自定义配置生成的token: {}...", &token[..50]);

    // 使用同样的管理器验证token
    let decoded_session: SessionData = jwt_manager.verify_token(&token)?;
    println!("   解析出的会话数据: {:?}", decoded_session);

    assert_eq!(session_data, decoded_session);
    println!("   ✓ 自定义配置验证通过\n");

    Ok(())
}

fn example_different_payloads() -> Result<()> {
    println!("3. 不同类型的payload支持:");

    // 字符串payload
    let simple_data = "Hello JWT World!";
    let token1 = generate_token(&simple_data, JwtConfig::default())?;
    let decoded_string: String = verify_token(&token1)?;
    println!("   字符串payload: {} -> {}", simple_data, decoded_string);

    // 数字payload
    let number_data = 42i32;
    let token2 = generate_token(&number_data, JwtConfig::default())?;
    let decoded_number: i32 = verify_token(&token2)?;
    println!("   数字payload: {} -> {}", number_data, decoded_number);

    // 复杂结构体
    #[derive(Serialize, Deserialize, Debug, PartialEq)]
    struct ComplexData {
        name: String,
        values: Vec<i32>,
        metadata: std::collections::HashMap<String, String>,
    }

    let mut metadata = std::collections::HashMap::new();
    metadata.insert("version".to_string(), "1.0".to_string());
    metadata.insert("env".to_string(), "production".to_string());

    let complex_data = ComplexData {
        name: "test_data".to_string(),
        values: vec![1, 2, 3, 4, 5],
        metadata,
    };

    let token3 = generate_token(&complex_data, JwtConfig::default())?;
    let decoded_complex: ComplexData = verify_token(&token3)?;
    println!("   复杂结构体payload: {:?}", decoded_complex);

    assert_eq!(complex_data, decoded_complex);
    println!("   ✓ 不同类型payload验证通过\n");

    Ok(())
}

fn example_error_handling() -> Result<()> {
    println!("4. 错误处理示例:");

    // 无效的token
    let invalid_token = "invalid.jwt.token";
    match verify_token::<User>(invalid_token) {
        Ok(_) => println!("   意外：无效token被接受了"),
        Err(e) => println!("   ✓ 无效token正确被拒绝: {}", e),
    }

    // 不同密钥的token
    let config1 = JwtConfig::new("secret1", 7);
    let config2 = JwtConfig::new("secret2", 7);
    let manager1 = JwtManager::new(config1);
    let manager2 = JwtManager::new(config2);

    let user = User {
        id: "test".to_string(),
        username: "test_user".to_string(),
        email: "test@example.com".to_string(),
        role: "user".to_string(),
    };

    let token = manager1.generate_token(&user)?;
    match manager2.verify_token::<User>(&token) {
        Ok(_) => println!("   意外：不同密钥的token被接受了"),
        Err(e) => println!("   ✓ 不同密钥的token正确被拒绝: {}", e),
    }

    println!("   ✓ 错误处理验证完成\n");

    Ok(())
}

examples/error_handling.rs (line 34)

fn example_jwt_error_handling() -> Result<()> {
    println!("1. JWT错误处理:");

    // 测试无效密钥
    let empty_config = JwtConfig::new("", 7); // 空密钥
    let manager = JwtManager::new(empty_config);

    let user = User {
        id: "123".to_string(),
        username: "test_user".to_string(),
        email: "test@example.com".to_string(),
        role: "user".to_string(),
    };

    match manager.generate_token(&user) {
        Ok(_) => println!("   意外：空密钥应该失败"),
        Err(ClamberError::JwtKeyError { details }) => {
            println!("   ✓ 正确检测到密钥错误: {}", details);
        }
        Err(e) => println!("   ? 其他错误: {}", e),
    }

    // 测试无效token验证
    let valid_config = JwtConfig::new("valid_secret", 7);
    let valid_manager = JwtManager::new(valid_config);

    match valid_manager.verify_token::<User>("invalid.jwt.token") {
        Ok(_) => println!("   意外：无效token应该失败"),
        Err(ClamberError::JwtVerifyError { details }) => {
            println!("   ✓ 正确检测到JWT验证错误: {}", details);
        }
        Err(e) => println!("   ? 其他JWT错误: {}", e),
    }

    // 测试不同类型的错误处理
    let config1 = JwtConfig::new("secret1", 7);
    let config2 = JwtConfig::new("secret2", 7);
    let manager1 = JwtManager::new(config1);
    let manager2 = JwtManager::new(config2);

    let token = manager1.generate_token(&user)?;

    match manager2.verify_token::<User>(&token) {
        Ok(_) => println!("   意外：不同密钥应该失败"),
        Err(ClamberError::JwtVerifyError { details }) => {
            println!("   ✓ 正确检测到密钥不匹配: {}", details);
        }
        Err(e) => println!("   ? 其他错误: {}", e),
    }

    println!();
    Ok(())
}

fn example_success_case() -> Result<()> {
    println!("2. 成功案例:");

    let user = User {
        id: "456".to_string(),
        username: "success_user".to_string(),
        email: "success@example.com".to_string(),
        role: "admin".to_string(),
    };

    // 使用便利函数
    let token = generate_token(&user, JwtConfig::default()).map_err(|e| {
        println!("   生成token失败: {}", e);
        e
    })?;

    println!("   ✓ 成功生成token");

    // 检查有效性
    if is_valid_token(&token) {
        println!("   ✓ Token有效性验证通过");
    } else {
        println!("   ✗ Token无效");
    }

    // 验证并解析
    let decoded_user: User = verify_token(&token).map_err(|e| {
        println!("   验证token失败: {}", e);
        e
    })?;

    println!("   ✓ 成功验证并解析token");
    println!("   ✓ 用户数据: {:?}", decoded_user);

    assert_eq!(user, decoded_user);
    println!("   ✓ 数据一致性验证通过");

    println!();
    Ok(())
}

// 展示如何在实际应用中处理错误
fn demonstrate_error_handling_patterns() {
    println!("   演示不同的错误处理模式:");

    // 模式1：具体错误类型处理
    println!("\n   模式1：具体错误类型匹配");
    let invalid_token = "invalid.token";
    match verify_token::<User>(invalid_token) {
        Ok(user) => println!("   用户验证成功: {:?}", user),
        Err(ClamberError::JwtExpiredError) => {
            println!("   → Token已过期，请重新登录");
        }
        Err(ClamberError::JwtVerifyError { details }) => {
            println!("   → Token验证失败: {}", details);
        }
        Err(ClamberError::JwtMissingFieldError { field }) => {
            println!("   → Token格式错误，缺少字段: {}", field);
        }
        Err(ClamberError::DeserializationError { details }) => {
            println!("   → 数据格式错误: {}", details);
        }
        Err(e) => {
            println!("   → 未知错误: {}", e);
        }
    }

    // 模式2：错误传播
    println!("\n   模式2：错误传播（? 操作符）");
    let result = (|| -> Result<()> {
        let user = User {
            id: "test".to_string(),
            username: "test".to_string(),
            email: "test@example.com".to_string(),
            role: "user".to_string(),
        };
        let token = generate_token(&user, JwtConfig::default())?;
        let _decoded: User = verify_token(&token)?;
        Ok(())
    })();

    match result {
        Ok(()) => println!("   ✓ 操作序列成功完成"),
        Err(e) => println!("   ✗ 操作序列失败: {}", e),
    }

    // 模式3：错误转换和上下文
    println!("\n   模式3：错误上下文处理");
    let result = (|| -> Result<String> {
        let config = JwtConfig::new("test_secret", 1);
        let manager = JwtManager::new(config);

        let user = User {
            id: "context_test".to_string(),
            username: "context_user".to_string(),
            email: "context@example.com".to_string(),
            role: "user".to_string(),
        };

        manager.generate_token(&user)
    })();

    match result {
        Ok(token) => println!("   ✓ 生成token成功: {}...", &token[..20]),
        Err(e) => println!("   ✗ 生成token失败: {}", e),
    }

    println!("\n   ✓ 错误处理模式演示完成");
}

Trait Implementations

impl Clone for JwtConfig

fn clone(&self) -> JwtConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JwtConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for JwtConfig

fn default() -> Self

Returns the “default value” for a type.