Struct actix_web::Json

pub struct Json<T>(pub T);

Json helper

Json can be used for two different purpose. First is for json response generation and second is for extracting typed information from request's payload.

Methods

impl<T> Json<T>

pub fn into_inner(self) -> T

Deconstruct to an inner value

Trait Implementations

impl<T> Deref for Json<T>

type Target = T

The resulting type after dereferencing.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Json<T>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Mutably dereferences the value.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

The Json type allows you to respond with well-formed JSON data: simply return a value of type Json where T is the type of a structure to serialize into JSON. The type T must implement the Serialize trait from serde.

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

fn index(req: HttpRequest) -> Result<Json<MyObj>> {
    Ok(Json(MyObj{name: req.match_info().query("name")?}))
}

type Item = HttpResponse

The associated item which can be returned.

type Error = Error

The associated error which can be returned.

fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error>

Convert itself to Reply or Error.

impl<T, S> FromRequest<S> for Json<T> where
    T: DeserializeOwned + 'static,
    S: 'static, 

To extract typed information from request's body, the type T must implement the Deserialize trait from serde.

JsonConfig allows to configure extraction process.

Example

#[macro_use] extern crate serde_derive;
use actix_web::{App, Json, Result, http};

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

/// deserialize `Info` from request's body
fn index(info: Json<Info>) -> Result<String> {
    Ok(format!("Welcome {}!", info.username))
}

fn main() {
    let app = App::new().resource(
       "/index.html",
       |r| r.method(http::Method::POST).with(index));  // <- use `with` extractor
}

type Config = JsonConfig

Configuration for conversion process

type Result = Box<Future<Item = Self, Error = Error>>

Future that resolves to a Self

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

Convert request to a Self