Trait axum::handler::Handler[−][src]

pub trait Handler<B, T>: Clone + Send + Sized + 'static {
    fn call<'async_trait>(
        self, 
        req: Request<B>
    ) -> Pin<Box<dyn Future<Output = Response<BoxBody>> + Send + 'async_trait>>
    where
        Self: 'async_trait;

    fn layer<L>(self, layer: L) -> Layered<L::Service, T>
    where
        L: Layer<IntoService<Self, B, T>>,
    { ... }

    fn into_service(self) -> IntoService<Self, B, T> { ... }

    fn into_make_service(self) -> IntoMakeService<IntoService<Self, B, T>> { ... }

    fn into_make_service_with_connect_info<C, Target>(
        self
    ) -> IntoMakeServiceWithConnectInfo<IntoService<Self, B, T>, C>
    where
        C: Connected<Target>,
    { ... }
}
Expand description

Trait for async functions that can be used to handle requests.

You shouldn’t need to depend on this trait directly. It is automatically implemented to closures of the right types.

See the module docs for more details.

Required methods

Call the handler with the given request.

Provided methods

Apply a tower::Layer to the handler.

All requests to the handler will be processed by the layer’s corresponding middleware.

This can be used to add additional processing to a request for a single handler.

Note this differs from routing::Router::layer which adds a middleware to a group of routes.

If you’re applying middleware that produces errors you have to handle the errors so they’re converted into responses. You can learn more about doing that here.

Example

Adding the tower::limit::ConcurrencyLimit middleware to a handler can be done like so:

use axum::{
    routing::get,
    handler::Handler,
    Router,
};
use tower::limit::{ConcurrencyLimitLayer, ConcurrencyLimit};

async fn handler() { /* ... */ }

let layered_handler = handler.layer(ConcurrencyLimitLayer::new(64));
let app = Router::new().route("/", get(layered_handler));

Convert the handler into a Service.

This is commonly used together with Router::fallback:

use axum::{
    Server,
    handler::Handler,
    http::{Uri, Method, StatusCode},
    response::IntoResponse,
    routing::{get, Router},
};
use tower::make::Shared;
use std::net::SocketAddr;

async fn handler(method: Method, uri: Uri) -> impl IntoResponse {
    (StatusCode::NOT_FOUND, format!("Nothing to see at {} {}", method, uri))
}

let app = Router::new()
    .route("/", get(|| async {}))
    .fallback(handler.into_service());

Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000)))
    .serve(app.into_make_service())
    .await?;

Convert the handler into a MakeService.

This allows you to serve a single handler if you don’t need any routing:

use axum::{
    Server, handler::Handler, http::{Uri, Method}, response::IntoResponse,
};
use std::net::SocketAddr;

async fn handler(method: Method, uri: Uri, body: String) -> impl IntoResponse {
    format!("received `{} {}` with body `{:?}`", method, uri, body)
}

Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000)))
    .serve(handler.into_make_service())
    .await?;

Convert the handler into a MakeService which stores information about the incoming connection.

See Router::into_make_service_with_connect_info for more details.

use axum::{
    Server,
    handler::Handler,
    response::IntoResponse,
    extract::ConnectInfo,
};
use std::net::SocketAddr;

async fn handler(ConnectInfo(addr): ConnectInfo<SocketAddr>) -> impl IntoResponse {
    format!("Hello {}", addr)
}

Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000)))
    .serve(handler.into_make_service_with_connect_info::<SocketAddr, _>())
    .await?;

Implementors