# actix_web::Json - Rust
API documentation for the Rust `Json` struct in crate `actix_web`.
Keywords: rust, rustlang, rust-lang, Json

# Struct actix_web::Json [−] [src]

    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.

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
    }

The `Json` type allows you to respond with well-formed JSON data: simply return a value of type Json<T> 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")?,
        }))
    }

## Methods

###

`impl<T> Json<T>`

[src]

####

`pub fn into_inner(self) -> T`

[src]

Deconstruct to an inner value

## Trait Implementations

###

`impl<T> Deref for Json<T>`

[src]

#### `type Target = T`

The resulting type after dereferencing.

####
ⓘImportant traits for &'a mut R

### Important traits for &'a mut R

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

`fn deref(&self) -> &T`

[src]

Dereferences the value.

###

`impl<T> DerefMut for Json<T>`

[src]

####
ⓘImportant traits for &'a mut R

### Important traits for &'a mut R

`impl<'a, R> Read for &'a mut R where
R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
W: Write + ?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`

[src]

Mutably dereferences the value.

###

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

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

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

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

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

[src]

#### `type Item = HttpResponse`

The associated item which can be returned.

#### `type Error = Error`

The associated error which can be returned.

####

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

[src]

Convert itself to `AsyncResult` or `Error`.

###

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

[src]

#### `type Config = JsonConfig<S>`

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`

[src]

Convert request to a Self

####

`fn extract(req: &HttpRequest<S>) -> Self::Result`

[src]

Convert request to a Self Read more

## Auto Trait Implementations

###

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

###

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

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)