Struct 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> Apiv2Schema for Json<T>

where T: Apiv2Schema,

JSON needs specialization because it updates the global definitions.

fn name() -> Option<String>

Name of this schema. This is the name to which the definition of the object is mapped.

fn raw_schema() -> DefaultSchemaRaw

Returns the raw schema for this object.

fn description() -> &'static str

Description of this schema. In case the trait is derived, uses the documentation on the type.

fn required() -> bool

Indicates the requirement of this schema.

fn schema_with_ref() -> DefaultSchemaRaw

Returns the schema with a reference (if this is an object).

fn security_scheme() -> Option<SecurityScheme>

Returns the security scheme for this object.

fn header_parameter_schema() -> Vec<Parameter<DefaultSchemaRaw>>

impl<T> Debug for Json<T>

where T: Debug,

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

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 for Json<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T> FromRequest for Json<T>

where T: DeserializeOwned,

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, ) -> <Json<T> as FromRequest>::Future

Create a Self from request parts asynchronously.

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

Create a Self from request head asynchronously.

impl<T> OperationModifier for Json<T>

where T: Apiv2Schema,

fn update_parameter( op: &mut Operation<Parameter<DefaultSchemaRaw>, Response<DefaultSchemaRaw>>, )

Update the parameters list in the given operation (if needed).

fn update_response( op: &mut Operation<Parameter<DefaultSchemaRaw>, Response<DefaultSchemaRaw>>, )

Update the responses map in the given operation (if needed).

fn update_definitions(map: &mut BTreeMap<String, DefaultSchemaRaw>)

Update the definitions map (if needed).

fn update_security( op: &mut Operation<Parameter<DefaultSchemaRaw>, Response<DefaultSchemaRaw>>, )

Update the security map in the given operation (if needed).

fn update_security_definitions(map: &mut BTreeMap<String, SecurityScheme>)

Update the security definition map (if needed).

impl<T> Responder for Json<T>

where T: Serialize,

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<<Json<T> as Responder>::Body>

Convert self to HttpResponse.

fn customize(self) -> CustomizeResponder<Self>

where Self: Sized,

Wraps responder to allow alteration of its response.

impl<T> Serialize for Json<T>

where T: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.