Trait Responder 

pub trait Responder {
    type Body: MessageBody + 'static;

    // Required method
    fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body>;

    // Provided method
    fn customize(self) -> CustomizeResponder<Self>
       where Self: Sized { ... }
}

Trait implemented by types that can be converted to an HTTP response.

Any types that implement this trait can be used in the return type of a handler. Since handlers will only have one return type, it is idiomatic to use opaque return types -> impl Responder.

Implementations

It is often not required to implement Responder for your own types due to a broad base of built-in implementations:

• HttpResponse and HttpResponseBuilder
• Option<R> where R: Responder
• Result<R, E> where R: Responder and E: ResponseError
• (R, StatusCode) where R: Responder
• &'static str, String, &'_ String, Cow<'_, str>, ByteString
• &'static [u8], Vec<u8>, Bytes, BytesMut
• Json<T> and Form<T> where T: Serialize
• Either<L, R> where L: Serialize and R: Serialize
• CustomizeResponder<R>
• actix_files::NamedFile
• Experimental responders from actix-web-lab
• Third party integrations may also have implemented Responder where appropriate. For example, HTML templating engines.

Customizing Responder Output

Calling .customize() on any responder type will wrap it in a CustomizeResponder capable of overriding various parts of the response such as the status code and header map.

Required Associated Types

type Body: MessageBody + 'static

Required Methods

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

Convert self to HttpResponse.

Provided Methods

fn customize(self) -> CustomizeResponder<Self>

where Self: Sized,

Wraps responder to allow alteration of its response.

See CustomizeResponder docs for more details on its capabilities.

Examples

use actix_web::{Responder, http::StatusCode, test::TestRequest};

let responder = "Hello world!"
    .customize()
    .with_status(StatusCode::BAD_REQUEST)
    .insert_header(("x-hello", "world"));

let request = TestRequest::default().to_http_request();
let response = responder.respond_to(&request);
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
assert_eq!(response.headers().get("x-hello").unwrap(), "world");

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Responder for &'static [u8]

type Body = &'static [u8]

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

impl Responder for &'static str

type Body = &'static str

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

impl Responder for &String

type Body = String

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

impl Responder for ByteString

type Body = ByteString

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

impl Responder for Cow<'_, str>

type Body = String

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

impl Responder for ResponseBuilder

type Body = BoxBody

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

impl Responder for String

type Body = String

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

impl Responder for Vec<u8>

type Body = Vec<u8>

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

impl<E> Responder for Result<(), E>

where E: Into<Error>,

type Body = BoxBody

fn respond_to(self, _req: &HttpRequest) -> HttpResponse

impl<R, E> Responder for Result<R, E>

where R: Responder, E: Into<Error>,

type Body = EitherBody<<R as Responder>::Body>

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

impl<R: Responder> Responder for (R, StatusCode)

type Body = <R as Responder>::Body

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

impl<R: Responder> Responder for Option<R>

type Body = EitherBody<<R as Responder>::Body>

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

Implementors

impl Responder for Bytes

type Body = Bytes

impl Responder for BytesMut

type Body = BytesMut

impl Responder for Html

type Body = String

impl Responder for HttpResponseBuilder

type Body = BoxBody

impl Responder for Redirect

type Body = ()

impl Responder for Response<BoxBody>

type Body = BoxBody

impl<B> Responder for HttpResponse<B>

where B: MessageBody + 'static,

type Body = B

impl<L, R> Responder for Either<L, R>

where L: Responder, R: Responder,

See here for example of usage as a handler return type.

type Body = EitherBody<<L as Responder>::Body, <R as Responder>::Body>

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

See here for example of usage as a handler return type.

type Body = EitherBody<String>

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>

impl<T> Responder for CustomizeResponder<T>

where T: Responder,

type Body = EitherBody<<T as Responder>::Body>

impl<T> Responder for InternalError<T>

where T: Debug + Display + 'static,

type Body = BoxBody