如何在Axum框架中将结构体方法用作请求处理器？

问题背景 #

当请求处理器为独立函数时，以下代码可正常运行：

use axum::{
    routing::{get, post},
    http::StatusCode,
    response::IntoResponse,
    Json, Router,
};
use serde::Serialize;
use std::net::SocketAddr;

#[tokio::main]
async fn main() -> () {
    // 构建路由应用
    let app = Router::new()
        // GET / 映射到root处理器
        .route("/", axum::routing::get(root));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

// 基础处理器，返回序列化后的Person结构体
async fn root() -> impl IntoResponse {
    let person = Person {
        age: 20,
        name: "John".to_string()
    };
    (StatusCode::OK, Json(person))
}

// 补充定义Person结构体（原代码遗漏，用于序列化）
#[derive(Serialize)]
struct Person {
    age: u32,
    name: String,
}

但实际项目中需要将处理器逻辑封装为结构体方法，尝试实现时出现编译错误，相关代码及错误信息如下：

出错代码 #

use axum::{
    routing::{get, post},
    http::StatusCode,
    response::IntoResponse,
    Json, Router,
};
use std::net::SocketAddr;

mod http {
    pub struct ServerLogic {
    }

    impl ServerLogic {
        pub fn new() -> Self {
            Self {}
        }
        pub fn hello(&self) -> impl axum::response::IntoResponse {
            (axum::http::StatusCode::OK, axum::Json("Hello, world!"))
        }
    }
}

#[tokio::main]
async fn main() -> () {
    // 构建路由应用
    let app = Router::new()
        // 尝试将结构体方法作为处理器
        .route("/", axum::routing::get(crate::http::ServerLogic::new().hello));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

编译错误信息 #

error[E0615]: attempted to take value of method `hello` on type `ServerLogic`
   --> src/main.rs:104:72
    |
104 |         .route("/", axum::routing::get(crate::http::ServerLogic::new().hello));
    |                                                                        ^^^^^ method, not a field
    |
help: use parentheses to call the method
    |
104 |         .route("/", axum::routing::get(crate::http::ServerLogic::new().hello()));
    |                                                                             ++

解决方案 #

要将结构体方法用作Axum请求处理器，核心是解决方法需要&self引用和Axum处理器需符合特定签名的问题，常用两种实现方式：

方式一：闭包包裹方法调用 #

直接用闭包捕获结构体实例，在闭包内调用方法。注意Axum处理器通常要求异步，因此建议将结构体方法定义为异步：

use axum::{
    routing::{get, post},
    http::StatusCode,
    response::IntoResponse,
    Json, Router,
};
use std::net::SocketAddr;

mod http {
    pub struct ServerLogic {
    }

    impl ServerLogic {
        pub fn new() -> Self {
            Self {}
        }
        // 定义为异步方法，符合Axum处理器要求
        pub async fn hello(&self) -> impl axum::response::IntoResponse {
            (axum::http::StatusCode::OK, axum::Json("Hello, world!"))
        }
    }
}

#[tokio::main]
async fn main() -> () {
    let server_logic = crate::http::ServerLogic::new();
    
    let app = Router::new()
        // 用闭包捕获实例，调用异步方法
        .route("/", get(move || server_logic.hello()));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

方式二：将结构体作为State注入（推荐） #

如果多个路由需要共享同一个结构体实例，推荐使用Axum的State机制，将实例注入路由后，通过State提取器在处理器中获取并调用方法：

use axum::{
    routing::{get, post},
    http::StatusCode,
    response::IntoResponse,
    Json, Router,
    extract::State, // 引入State提取器
};
use std::net::SocketAddr;
use std::sync::Arc; // 用Arc实现多线程安全共享

mod http {
    pub struct ServerLogic {
        app_name: String, // 示例字段：应用名称
    }

    impl ServerLogic {
        pub fn new(app_name: String) -> Self {
            Self { app_name }
        }
        pub async fn hello(&self) -> impl axum::response::IntoResponse {
            let msg = format!("Hello, world! From {}", self.app_name);
            (axum::http::StatusCode::OK, axum::Json(msg))
        }
        
        // 另一个示例方法，演示多路由共享实例
        pub async fn health(&self) -> impl axum::response::IntoResponse {
            (axum::http::StatusCode::OK, axum::Json("Healthy"))
        }
    }
}

#[tokio::main]
async fn main() -> () {
    // 创建实例并用Arc包裹，支持多线程共享
    let server_logic = Arc::new(crate::http::ServerLogic::new("MyAxumApp".to_string()));
    
    let app = Router::new()
        .route("/", get(handler_hello))
        .route("/health", get(handler_health))
        .with_state(server_logic); // 注入State

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

// 通过State提取器获取实例，调用方法
async fn handler_hello(State(server_logic): State<Arc<crate::http::ServerLogic>>) -> impl IntoResponse {
    server_logic.hello().await
}

async fn handler_health(State(server_logic): State<Arc<crate::http::ServerLogic>>) -> impl IntoResponse {
    server_logic.health().await
}

关键说明 #

1. 签名匹配：Axum处理器需为异步函数或返回IntoFuture类型，因此结构体方法建议定义为async fn。
2. 所有权与共享：闭包方式通过move转移实例所有权；State方式用Arc实现多线程安全共享，适合多路由场景。
3. 错误误区：编译器提示的hello()是直接调用方法返回响应值，而非传递处理器函数，因此不能直接使用——Axum需要的是可调用的处理器逻辑，而非预先计算的响应。

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