Struct axum::Extension

pub struct Extension<T>(pub T);

Extractor and response for extensions.

As extractor

This is commonly used to share state across handlers.

use axum::{
    Router,
    Extension,
    routing::get,
};
use std::sync::Arc;

// Some shared state used throughout our application
struct State {
    // ...
}

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

let state = Arc::new(State { /* ... */ });

let app = Router::new().route("/", get(handler))
    // Add middleware that inserts the state into all incoming request's
    // extensions.
    .layer(Extension(state));

If the extension is missing it will reject the request with a 500 Internal Server Error response.

As response

Response extensions can be used to share state with middleware.

use axum::{
    Extension,
    response::IntoResponse,
};

async fn handler() -> (Extension<Foo>, &'static str) {
    (
        Extension(Foo("foo")),
        "Hello, World!"
    )
}

#[derive(Clone)]
struct Foo(&'static str);

Tuple Fields

0: T

Trait Implementations

impl<T: Clone> Clone for Extension<T>

fn clone(&self) -> Extension<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Extension<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Extension<T>

fn default() -> Extension<T>

Returns the “default value” for a type.

impl<T> Deref for Extension<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S> FromRequestParts<S> for Extension<T> where
    T: Clone + Send + Sync + 'static,
    S: Send + Sync, 

type Rejection = ExtensionRejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request_parts<'life0, 'life1, 'async_trait>(
    req: &'life0 mut Parts,
    _state: &'life1 S
) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Perform the extraction.

impl<T> IntoResponse for Extension<T> where
    T: Send + Sync + 'static, 

fn into_response(self) -> Response

Create a response.

impl<T> IntoResponseParts for Extension<T> where
    T: Send + Sync + 'static, 

type Error = Infallible

The type returned in the event of an error.

fn into_response_parts(
    self,
    res: ResponseParts
) -> Result<ResponseParts, Self::Error>

Set parts of the response

impl<S, T> Layer<S> for Extension<T> where
    T: Clone + Send + Sync + 'static, 

type Service = AddExtension<S, T>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.

impl<T: Copy> Copy for Extension<T>