Struct actix_web::web::Json

pub struct Json<T>(pub T);

JSON extractor and responder.

Json has two uses: JSON responses, and extracting typed data from JSON request payloads.

Extractor

To extract typed data from a request body, the inner type T must implement the serde::Deserialize trait.

Use JsonConfig to configure extraction options.

use actix_web::{post, web, App};
use serde::Deserialize;

#[derive(Deserialize)]
struct Info {
    username: String,
}

/// deserialize `Info` from request's body
#[post("/")]
async fn index(info: web::Json<Info>) -> String {
    format!("Welcome {}!", info.username)
}

Responder

The Json type JSON formatted responses. A handler may return a value of type Json<T> where T is the type of a structure to serialize into JSON. The type T must implement serde::Serialize.

use actix_web::{post, web, HttpRequest};
use serde::Serialize;

#[derive(Serialize)]
struct Info {
    name: String,
}

#[post("/{name}")]
async fn index(req: HttpRequest) -> web::Json<Info> {
    web::Json(Info {
        name: req.match_info().get("name").unwrap().to_owned(),
    })
}

Tuple Fields

0: T

Implementations

impl<T> Json<T>

pub fn into_inner(self) -> T

Unwrap into inner T value.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T> Deref for Json<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Json<T>

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

Mutably dereferences the value.

impl<T: Display> Display for Json<T>

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

Formats the value using the given formatter.

impl<T: DeserializeOwned> FromRequest for Json<T>

See here for example of usage as an extractor.

type Error = Error

The associated error which can be returned.

type Future = JsonExtractFut<T>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.

impl<T: Serialize> Responder for Json<T>

Creates response with OK status code, correct content type header, and serialized JSON payload.

If serialization failed

type Body = EitherBody<String>

fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body>

Convert self to HttpResponse.

fn customize(self) -> CustomizeResponder<Self> where
    Self: Sized, 

Wraps responder to allow alteration of its response.

impl<T: Serialize> Serialize for Json<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.