Struct Route 

pub struct Route { /* private fields */ }

A request handler with guards.

Route uses a builder-like pattern for configuration. If handler is not set, a 404 Not Found handler is used.

Implementations

impl Route

pub fn new() -> Route

Create new route which matches any request.

pub fn wrap<M, B>(self, mw: M) -> Route

where M: Transform<BoxService<ServiceRequest, ServiceResponse, Error>, ServiceRequest, Response = ServiceResponse<B>, Error = Error, InitError = ()> + 'static, B: MessageBody + 'static,

Registers a route middleware.

mw is a middleware component (type), that can modify the requests and responses handled by this Route.

This middleware wraps the currently configured route service. Call this method after Route::to or Route::service so the middleware is applied to the final handler.

Examples

web::get()
    .to(|| async { HttpResponse::Ok() })
    .wrap(middleware::Logger::default());

See App::wrap for more details.

impl Route

pub fn method(self, method: Method) -> Self

Add method guard to the route.

Examples

App::new().service(web::resource("/path").route(
    web::get()
        .method(http::Method::CONNECT)
        .guard(guard::Header("content-type", "text/plain"))
        .to(|req: HttpRequest| HttpResponse::Ok()))
);

pub fn guard<F: Guard + 'static>(self, f: F) -> Self

Add guard to the route.

Examples

App::new().service(web::resource("/path").route(
    web::route()
        .guard(guard::Get())
        .guard(guard::Header("content-type", "text/plain"))
        .to(|req: HttpRequest| HttpResponse::Ok()))
);

pub fn to<F, Args>(self, handler: F) -> Self

where F: Handler<Args>, Args: FromRequest + 'static, F::Output: Responder + 'static,

Set handler function, use request extractors for parameters.

Examples

use actix_web::{web, http, App};
use serde::Deserialize;

#[derive(Deserialize)]
struct Info {
    username: String,
}

/// extract path info using serde
async fn index(info: web::Path<Info>) -> String {
    format!("Welcome {}!", info.username)
}

let app = App::new().service(
    web::resource("/{username}/index.html") // <- define path parameters
        .route(web::get().to(index))        // <- register handler
);

It is possible to use multiple extractors for one handler function.

use actix_web::{web, App};

#[derive(Deserialize)]
struct Info {
    username: String,
}

/// extract path info using serde
async fn index(
    path: web::Path<Info>,
    query: web::Query<HashMap<String, String>>,
    body: web::Json<Info>
) -> String {
    format!("Welcome {}!", path.username)
}

let app = App::new().service(
    web::resource("/{username}/index.html") // <- define path parameters
        .route(web::get().to(index))
);

Panics

Panics if called after Route::wrap, since this would replace the wrapped service and silently discard middleware.

pub fn service<S, E>(self, service_factory: S) -> Self

where S: ServiceFactory<ServiceRequest, Response = ServiceResponse, Error = E, InitError = (), Config = ()> + 'static, E: Into<Error> + 'static,

Set raw service to be constructed and called as the request handler.

Examples

struct HelloWorld;

impl Service<ServiceRequest> for HelloWorld {
    type Response = ServiceResponse;
    type Error = Infallible;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    dev::always_ready!();

    fn call(&self, req: ServiceRequest) -> Self::Future {
        let (req, _) = req.into_parts();

        let res = HttpResponse::Ok()
            .insert_header(header::ContentType::plaintext())
            .body("Hello world!");

        Box::pin(async move { Ok(ServiceResponse::new(req, res)) })
    }
}

App::new().route(
    "/",
    web::get().service(fn_factory(|| async { Ok(HelloWorld) })),
);

Panics

Panics if called after Route::wrap, since this would replace the wrapped service and silently discard middleware.

Trait Implementations

impl ServiceFactory<ServiceRequest> for Route

type Response = ServiceResponse

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = RouteService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Pin<Box<dyn Future<Output = Result<<Route as ServiceFactory<ServiceRequest>>::Service, <Route as ServiceFactory<ServiceRequest>>::InitError>>>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.