Struct actix_web::middleware::ErrorHandlers

pub struct ErrorHandlers<S> { /* fields omitted */ }

Middleware for allowing custom handlers for responses.

You can use ErrorHandlers::handler() method to register a custom error handler for specific status code. You can modify existing response or create completely new one.

Example

use actix_web::middleware::{ErrorHandlers, Response};
use actix_web::{http, App, HttpRequest, HttpResponse, Result};

fn render_500<S>(_: &HttpRequest<S>, resp: HttpResponse) -> Result<Response> {
    let mut builder = resp.into_builder();
    builder.header(http::header::CONTENT_TYPE, "application/json");
    Ok(Response::Done(builder.into()))
}

fn main() {
    let app = App::new()
        .middleware(
            ErrorHandlers::new()
                .handler(http::StatusCode::INTERNAL_SERVER_ERROR, render_500),
        )
        .resource("/test", |r| {
            r.method(http::Method::GET).f(|_| HttpResponse::Ok());
            r.method(http::Method::HEAD)
                .f(|_| HttpResponse::MethodNotAllowed());
        })
        .finish();
}

Methods

impl<S> ErrorHandlers<S>

pub fn new() -> Self

Construct new ErrorHandlers instance

pub fn handler<F>(self, status: StatusCode, handler: F) -> Self where
    F: Fn(&HttpRequest<S>, HttpResponse) -> Result<Response> + 'static, 

Register error handler for specified status code

Trait Implementations

impl<S: 'static> Middleware<S> for ErrorHandlers<S>

fn response(&self, req: &HttpRequest<S>, resp: HttpResponse) -> Result<Response>

Method is called when handler returns response, but before sending http message to peer.

fn start(&self, req: &HttpRequest<S>) -> Result<Started>

Method is called when request is ready. It may return future, which should resolve before next middleware get called.

fn finish(&self, req: &HttpRequest<S>, resp: &HttpResponse) -> Finished

Method is called after body stream get sent to peer.

impl<S> Default for ErrorHandlers<S>

fn default() -> Self

Returns the "default value" for a type.