如何在Rocket/Juniper Context中使用PickleDB？Rust开发求助

你遇到的问题核心在于Rocket的State管理的是共享实例，只能通过引用访问，而你最初尝试让Context持有PickleDb的所有权，这显然行不通——因为Rocket需要保留这个实例的所有权来在多个请求间共享。而使用引用时的生命周期问题，是因为没有正确将Context的生命周期和请求的生命周期绑定起来。

下面是分步的解决方案：

1. 调整Context结构体，绑定请求生命周期 #

首先，修改你的Context，让它持有一个带生命周期的PickleDb引用，这个生命周期要和FromRequest的请求生命周期对齐：

pub struct Context<'a> {
    pickle_db: &'a PickleDb,
}

// 为带生命周期的Context实现Juniper的Context trait
impl<'a> juniper::Context for Context<'a> {}

impl<'a, 'r> FromRequest<'a, 'r> for Context<'a> {
    type Error = ();

    fn from_request(request: &'a Request<'r>) -> request::Outcome<Context<'a>, ()> {
        // 直接通过guard获取State，然后映射为Context
        request.guard::<State<PickleDb>>()
            .map(|state| Context { pickle_db: state.inner() })
    }
}

这里的关键是：

• Context的生命周期'a和FromRequest的'a参数绑定，确保引用的生命周期和当前请求的生命周期一致
• 使用map方法将State的结果转换为Context，避免手动处理Outcome的细节

2. 在Resolver中使用带生命周期的Context #

在你的GraphQL查询/变更解析器中，需要指定Context的生命周期（可以用'_匿名生命周期简化）：

struct Query;

#[juniper::object(Context = Context<'a>)]
impl Query {
    fn get_value(context: &Context<'_>, key: String) -> Option<String> {
        // 直接通过引用访问PickleDb
        context.pickle_db.get::<String>(&key)
    }
}

struct Mutation;

#[juniper::object(Context = Context<'a>)]
impl Mutation {
    fn set_value(context: &Context<'_>, key: String, value: String) -> bool {
        context.pickle_db.set(&key, &value).is_ok()
    }
}

3. 处理线程安全（重要！） #

这里有个容易忽略的点：Rocket默认使用多线程调度器，要求State中的类型实现Send + Sync。如果PickleDb本身没有实现Sync（可以查看它的文档确认），多个请求同时访问会导致编译错误。

解决办法是用Mutex包裹PickleDb，确保线程安全：

修改Rocket启动代码： #

use std::sync::Mutex;

fn rocket() -> Rocket {
    let pickle_path = var_os(String::from("PICKLE_PATH")).unwrap_or(OsString::from("pickle.db"));
    let pickle_db_dump_policy = PickleDbDumpPolicy::PeriodicDump(Duration::from_secs(120));
    let pickle_serialization_method = SerializationMethod::Bin;
    let pickle_db: PickleDb = match Path::new(&pickle_path).exists() {
        false => PickleDb::new(pickle_path, pickle_db_dump_policy, pickle_serialization_method),
        true => PickleDb::load(pickle_path, pickle_db_dump_policy, pickle_serialization_method).unwrap(),
    };
    // 用Mutex包裹PickleDb
    let pickle_db = Mutex::new(pickle_db);
    
    rocket::ignite()
        .manage(Schema::new(Query, Mutation))
        .manage(pickle_db)
        .mount("/", routes![graphiql, get_graphql_handler, post_graphql_handler])
}

更新Context和Resolver： #

pub struct Context<'a> {
    pickle_db: &'a Mutex<PickleDb>,
}

impl<'a> juniper::Context for Context<'a> {}

impl<'a, 'r> FromRequest<'a, 'r> for Context<'a> {
    type Error = ();

    fn from_request(request: &'a Request<'r>) -> request::Outcome<Context<'a>, ()> {
        request.guard::<State<Mutex<PickleDb>>>()
            .map(|state| Context { pickle_db: state.inner() })
    }
}

// 解析器中需要先锁定Mutex
#[juniper::object(Context = Context<'a>)]
impl Query {
    fn get_value(context: &Context<'_>, key: String) -> Option<String> {
        // 锁定Mutex，处理可能的锁定失败（比如poisoned锁）
        let db = context.pickle_db.lock().ok()?;
        db.get::<String>(&key)
    }
}

#[juniper::object(Context = Context<'a>)]
impl Mutation {
    fn set_value(context: &Context<'_>, key: String, value: String) -> bool {
        let mut db = context.pickle_db.lock().ok()?;
        db.set(&key, &value).is_ok()
    }
}

你的初始实现方式是否正确？ #

你的思路方向是对的——通过Rocket的Guard机制将State注入到Juniper的Context中，但错误在于：

1. 试图获取PickleDb的所有权：Rocket的State是共享的，不能转移所有权，必须使用引用
2. 没有正确处理引用的生命周期：需要将Context的生命周期和请求的生命周期绑定，才能让编译器确认引用的有效性

按照上面的方案调整后，代码就能正常运行了。

内容的提问来源于stack exchange，提问作者arturh