Struct axum::handler::HandlerService

pub struct HandlerService<H, T, S, B> { /* private fields */ }

An adapter that makes a Handler into a Service.

Created with Handler::with_state or HandlerWithoutStateExt::into_service.

Implementations

impl<H, T, S, B> HandlerService<H, T, S, B>

pub fn state(&self) -> &S

Get a reference to the state.

pub fn into_make_service(self) -> IntoMakeService<HandlerService<H, T, S, B>>

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,
    extract::State,
    http::{Uri, Method},
    response::IntoResponse,
};
use std::net::SocketAddr;

#[derive(Clone)]
struct AppState {}

async fn handler(State(state): State<AppState>) {
    // ...
}

let app = handler.with_state(AppState {});

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

pub fn into_make_service_with_connect_info<C>( self ) -> IntoMakeServiceWithConnectInfo<HandlerService<H, T, S, B>, C>

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, State},
};
use std::net::SocketAddr;

#[derive(Clone)]
struct AppState {};

async fn handler(
    ConnectInfo(addr): ConnectInfo<SocketAddr>,
    State(state): State<AppState>,
) -> String {
    format!("Hello {}", addr)
}

let app = handler.with_state(AppState {});

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

Trait Implementations

impl<H, T, S, B> Clone for HandlerService<H, T, S, B>

where H: Clone, S: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H, T, S, B> Debug for HandlerService<H, T, S, B>

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

Formats the value using the given formatter.

impl<H, T, S, B> Service<Request<B>> for HandlerService<H, T, S, B>

where H: Handler<T, S, B> + Clone + Send + 'static, B: Send + 'static, S: Clone + Send + Sync,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = IntoServiceFuture<<H as Handler<T, S, B>>::Future>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<B>) -> Self::Future

Process the request and return the response asynchronously.