Struct JsonDeserializer

pub struct JsonDeserializer<T> { /* private fields */ }

Available on crate feature json-deserializer only.

JSON Extractor for zero-copy deserialization.

Deserialize request bodies into some type that implements serde::Deserialize<'de>. Parsing JSON is delayed until deserialize is called. If the type implements serde::de::DeserializeOwned, the Json extractor should be preferred.

The request will be rejected (and a JsonDeserializerRejection will be returned) if:

• The request doesn’t have a Content-Type: application/json (or similar) header.
• Buffering the request body fails.

Additionally, a JsonRejection error will be returned, when calling deserialize if:

• The body doesn’t contain syntactically valid JSON.
• The body contains syntactically valid JSON, but it couldn’t be deserialized into the target type.
• Attempting to deserialize escaped JSON into a type that must be borrowed (e.g. &'a str).

⚠️ serde will implicitly try to borrow for &str and &[u8] types, but will error if the input contains escaped characters. Use Cow<'a, str> or Cow<'a, [u8]>, with the #[serde(borrow)] attribute, to allow serde to fall back to an owned type when encountering escaped characters.

⚠️ Since parsing JSON requires consuming the request body, the Json extractor must be last if there are multiple extractors in a handler. See “the order of extractors”

See JsonDeserializerRejection for more details.

Example

use axum::{
    routing::post,
    Router,
    response::{IntoResponse, Response}
};
use axum_extra::extract::JsonDeserializer;
use serde::Deserialize;
use std::borrow::Cow;
use http::StatusCode;

#[derive(Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    borrow_text: Cow<'a, str>,
    #[serde(borrow)]
    borrow_bytes: Cow<'a, [u8]>,
    borrow_dangerous: &'a str,
    not_borrowed: String,
}

async fn upload(deserializer: JsonDeserializer<Data<'_>>) -> Response {
    let data = match deserializer.deserialize() {
        Ok(data) => data,
        Err(e) => return e.into_response(),
    };

    // payload is a `Data` with borrowed data from `deserializer`,
    // which owns the request body (`Bytes`).

    StatusCode::OK.into_response()
}

let app = Router::new().route("/upload", post(upload));

Implementations

impl<'de, 'a: 'de, T> JsonDeserializer<T>

where T: Deserialize<'de>,

pub fn deserialize(&'a self) -> Result<T, JsonDeserializerRejection>

Deserialize the request body into the target type. See JsonDeserializer for more details.

Trait Implementations

impl<T: Clone> Clone for JsonDeserializer<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for JsonDeserializer<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for JsonDeserializer<T>

fn default() -> JsonDeserializer<T>

Returns the “default value” for a type.

impl<T, S> FromRequest<S> for JsonDeserializer<T>

where T: Deserialize<'static>, S: Send + Sync,

type Rejection = JsonDeserializerRejection

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<'life0, 'async_trait>( req: Request, state: &'life0 S, ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Perform the extraction.