Rust GraphQL服务库juniper_axum的使用：集成Juniper与Axum实现高性能GraphQL API开发

juniper_axum crate

axum web服务器与juniper(Rust的GraphQL实现)的集成库。

文档

获取文档，包括指南和示例。

示例

以下是使用juniper_axum创建GraphQL服务器的完整示例：

use axum::{
    routing::get,
    Router,
};
use juniper::{
    graphql_object, EmptyMutation, EmptySubscription, RootNode,
};
use juniper_axum::{graphiql, graphql, playground};
use std::sync::Arc;

// 定义GraphQL上下文
struct Context;
impl juniper::Context for Context {}

// 定义查询类型
struct Query;

// 添加GraphQL解析器
#[graphql_object(context = Context)]
impl Query {
    fn hello(&self) -> &str {
        "Hello, world!"
    }
}

// 定义GraphQL Schema
type Schema = RootNode<'static, Query, EmptyMutation<Context>, EmptySubscription<Context>>;

#[tokio::main]
async fn main() {
    // 创建Schema实例
    let schema = Arc::new(Schema::new(
        Query,
        EmptyMutation::<Context>::new(),
        EmptySubscription::<Context>::new(),
    ));

    // 创建路由
    let app = Router::new()
        .route("/", get(graphiql("/graphql", None)).post(graphql))
        .route("/graphql", get(graphiql("/graphql", None)).post(graphql))
        .route("/playground", get(playground("/graphql", None)))
        .with_state(schema);

    // 启动服务器
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    println!("GraphQL server running at http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

完整示例demo

以下是一个更完整的GraphQL API示例，包含查询和变更操作：

use axum::{
    extract::State,
    routing::{get, post},
    Router,
};
use juniper::{
    graphql_object, graphql_subscription, EmptyMutation, EmptySubscription, FieldError, RootNode,
    GraphQLInputObject, GraphQLObject,
};
use juniper_axum::{graphiql, graphql, playground};
use std::sync::Arc;

// 定义用户数据结构
#[derive(GraphQLObject)]
struct User {
    id: i32,
    name: String,
    email: String,
}

// 定义用户输入
#[derive(GraphQLInputObject)]
struct NewUser {
    name: String,
    email: String,
}

// 定义GraphQL上下文
struct Database {
    users: Vec<User>,
}
impl juniper::Context for Database {}

// 定义查询类型
struct Query;

#[graphql_object(context = Database)]
impl Query {
    // 获取所有用户
    async fn users(context: &Database) -> Vec<User> {
        context.users.clone()
    }

    // 通过ID获取用户
    async fn user(context: &Database, id: i32) -> Option<User> {
        context.users.iter().find(|user| user.id == id).cloned()
    }
}

// 定义变更类型
struct Mutation;

#[graphql_object(context = Database)]
impl Mutation {
    // 创建新用户
    async fn create_user(context: &Database, new_user: NewUser) -> Result<User, FieldError> {
        let user = User {
            id: context.users.len() as i32 + 1,
            name: new_user.name,
            email: new_user.email,
        };
        // 在实际应用中这里应该将用户保存到数据库
        Ok(user)
    }
}

// 定义GraphQL Schema
type Schema = RootNode<'static, Query, Mutation, EmptySubscription<Database>>;

#[tokio::main]
async fn main() {
    // 初始化数据库
    let db = Arc::new(Database {
        users: vec![
            User {
                id: 1,
                name: "Alice".to_string(),
                email: "alice@example.com".to_string(),
            },
            User {
                id: 2,
                name: "Bob".to_string(),
                email: "bob@example.com".to_string(),
            },
        ],
    });

    // 创建Schema实例
    let schema = Arc::new(Schema::new(
        Query,
        Mutation,
        EmptySubscription::<Database>::new(),
    ));

    // 创建路由
    let app = Router::new()
        .route("/", get(graphiql("/graphql", None)).post(graphql))
        .route("/graphql", get(graphiql("/graphql", None)).post(graphql))
        .route("/playground", get(playground("/graphql", None)))
        .with_state(schema);

    // 启动服务器
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    println!("GraphQL server running at http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

安装

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

cargo add juniper_axum

或者在Cargo.toml中添加以下行：

juniper_axum = "0.2.0"

许可证

此项目采用BSD 2-Clause License许可证。