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::{http, App, HttpRequest, HttpResponse, Result};
use actix_web::middleware::{Response, ErrorHandlers};

fn render_500<S>(_: &mut 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(&mut HttpRequest<S>, HttpResponse) -> Result<Response> + 'static, 

Register error handler for specified status code

Trait Implementations

impl<S> Default for ErrorHandlers<S>

fn default() -> Self

Returns the "default value" for a type.

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

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

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

fn start(&self, req: &mut 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: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished

Method is called after body stream get sent to peer.