Struct Json

Source

pub struct Json<T>(pub T);

Expand description

JSON Extractor / Response.

When used as an extractor, it can deserialize request bodies into some type that implements serde::de::DeserializeOwned. The request will be rejected (and a JsonRejection will be returned) if:

The request doesn’t have a Content-Type: application/json (or similar) header.
The body doesn’t contain syntactically valid JSON.
The body contains syntactically valid JSON, but it couldn’t be deserialized into the target type.
Buffering the request body fails.

⚠️ 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 JsonRejection for more details.

§Extractor example

use axum::{
    extract,
    routing::post,
    Router,
};
use serde::Deserialize;

#[derive(Deserialize)]
struct CreateUser {
    email: String,
    password: String,
}

async fn create_user(extract::Json(payload): extract::Json<CreateUser>) {
    // payload is a `CreateUser`
}

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

When used as a response, it can serialize any type that implements serde::Serialize to JSON, and will automatically set Content-Type: application/json header.

If the Serialize implementation decides to fail or if a map with non-string keys is used, a 500 response will be issued whose body is the error message in UTF-8.

§Response example

use axum::{
    extract::Path,
    routing::get,
    Router,
    Json,
};
use serde::Serialize;
use uuid::Uuid;

#[derive(Serialize)]
struct User {
    id: Uuid,
    username: String,
}

async fn get_user(Path(user_id) : Path<Uuid>) -> Json<User> {
    let user = find_user(user_id).await;
    Json(user)
}

async fn find_user(user_id: Uuid) -> User {
    // ...
}

let app = Router::new().route("/users/:id", get(get_user));

Tuple Fields§

§0: T

Struct Json Copy item path

§Extractor example

§Response example

Tuple Fields§

Implementations§

impl<T> Json<T>where T: DeserializeOwned,

pub fn from_bytes(bytes: &[u8]) -> Result<Json<T>, JsonRejection>

Trait Implementations§

impl<T> Clone for Json<T>where T: Clone,

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

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

impl<T> Debug for Json<T>where T: Debug,

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

impl<T> Default for Json<T>where T: Default,

fn default() -> Json<T>

impl<T> Deref for Json<T>

type Target = T

fn deref(&self) -> &<Json<T> as Deref>::Target

impl<T> DerefMut for Json<T>

fn deref_mut(&mut self) -> &mut <Json<T> as Deref>::Target

impl<T> From<T> for Json<T>

fn from(inner: T) -> Json<T>

impl<T, S> FromRequest<S> for Json<T>where T: DeserializeOwned, S: Send + Sync,

type Rejection = JsonRejection

fn from_request<'life0, 'async_trait>( req: Request<Body>, state: &'life0 S, ) -> Pin<Box<dyn Future<Output = Result<Json<T>, <Json<T> as FromRequest<S>>::Rejection>> + Send + 'async_trait>>where 'life0: 'async_trait, Json<T>: 'async_trait,

impl<T> IntoResponse for Json<T>where T: Serialize,

fn into_response(self) -> Response<Body>

impl<T> Copy for Json<T>where T: Copy,

Auto Trait Implementations§

impl<T> Freeze for Json<T>where T: Freeze,

impl<T> RefUnwindSafe for Json<T>where T: RefUnwindSafe,

impl<T> Send for Json<T>where T: Send,

impl<T> Sync for Json<T>where T: Sync,

impl<T> Unpin for Json<T>where T: Unpin,

impl<T> UnsafeUnpin for Json<T>where T: UnsafeUnpin,

impl<T> UnwindSafe for Json<T>where T: UnwindSafe,

Blanket Implementations§

impl<T, A, P> Access<T> for Pwhere A: Access<T> + ?Sized, P: Deref<Target = A>,

type Guard = <A as Access<T>>::Guard

fn load(&self) -> <P as Access<T>>::Guard

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> Commands for Twhere T: ConnectionLike,

fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_options<'a, K, V, RV>( &mut self, key: K, value: V, options: SetOptions, ) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_multiple<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_ex<'a, K, V, RV>( &mut self, key: K, value: V, seconds: u64, ) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn pset_ex<'a, K, V, RV>( &mut self, key: K, value: V, milliseconds: u64, ) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn mset_nx<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn getrange<'a, K, RV>( &mut self, key: K, from: isize, to: isize, ) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn setrange<'a, K, V, RV>( &mut self, key: K, offset: isize, value: V, ) -> Result<RV, RedisError>where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn get_ex<'a, K, RV>( &mut self, key: K, expire_at: Expiry, ) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>where K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue,

fn rename_nx<'a, K, N, RV>( &mut self, key: K, new_key: N, ) -> Result<RV, RedisError>where K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue,

fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where K: ToRedisArgs, RV: FromRedisValue,

Struct Json

impl<T> Json<T>
where T: DeserializeOwned,

impl<T> Clone for Json<T>
where T: Clone,

impl<T> Debug for Json<T>
where T: Debug,

impl<T> Default for Json<T>
where T: Default,

impl<T, S> FromRequest<S> for Json<T>
where T: DeserializeOwned, S: Send + Sync,

fn from_request<'life0, 'async_trait>( req: Request<Body>, state: &'life0 S, ) -> Pin<Box<dyn Future<Output = Result<Json<T>, <Json<T> as FromRequest<S>>::Rejection>> + Send + 'async_trait>>
where 'life0: 'async_trait, Json<T>: 'async_trait,

impl<T> IntoResponse for Json<T>
where T: Serialize,

impl<T> Copy for Json<T>
where T: Copy,

impl<T> Freeze for Json<T>
where T: Freeze,

impl<T> RefUnwindSafe for Json<T>
where T: RefUnwindSafe,

impl<T> Send for Json<T>
where T: Send,

impl<T> Sync for Json<T>
where T: Sync,

impl<T> Unpin for Json<T>
where T: Unpin,

impl<T> UnsafeUnpin for Json<T>
where T: UnsafeUnpin,

impl<T> UnwindSafe for Json<T>
where T: UnwindSafe,

impl<T, A, P> Access<T> for P
where A: Access<T> + ?Sized, P: Deref<Target = A>,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T> Commands for T
where T: ConnectionLike,

fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_options<'a, K, V, RV>( &mut self, key: K, value: V, options: SetOptions, ) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_multiple<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_ex<'a, K, V, RV>( &mut self, key: K, value: V, seconds: u64, ) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn pset_ex<'a, K, V, RV>( &mut self, key: K, value: V, milliseconds: u64, ) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn mset_nx<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn getrange<'a, K, RV>( &mut self, key: K, from: isize, to: isize, ) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn setrange<'a, K, V, RV>( &mut self, key: K, offset: isize, value: V, ) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn get_ex<'a, K, RV>( &mut self, key: K, expire_at: Expiry, ) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
where K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue,

fn rename_nx<'a, K, N, RV>( &mut self, key: K, new_key: N, ) -> Result<RV, RedisError>
where K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue,

fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
where K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn setbit<'a, K, RV>( &mut self, key: K, offset: usize, value: bool, ) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn bitcount_range<'a, K, RV>( &mut self, key: K, start: usize, end: usize, ) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn bit_and<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
where D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue,

fn bit_or<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
where D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue,

fn bit_xor<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
where D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue,

fn bit_not<'a, D, S, RV>( &mut self, dstkey: D, srckey: S, ) -> Result<RV, RedisError>
where D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue,

fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>
where K: ToRedisArgs, RV: FromRedisValue,

fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hset<'a, K, F, V, RV>( &mut self, key: K, field: F, value: V, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn hset_nx<'a, K, F, V, RV>( &mut self, key: K, field: F, value: V, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn hset_multiple<'a, K, F, V, RV>( &mut self, key: K, items: &'a [(F, V)], ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue,

fn hincr<'a, K, F, D, RV>( &mut self, key: K, field: F, delta: D, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue,

fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hexpire<'a, K, F, RV>( &mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hexpire_at<'a, K, F, RV>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hexpire_time<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hpersist<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hpexpire<'a, K, F, RV>( &mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,

fn hpexpire_at<'a, K, F, RV>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
where K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue,