Struct actix_web::Resource

pub struct Resource<T = ResourceEndpoint> { /* private fields */ }

A collection of Routes that respond to the same path pattern.

Resource in turn has at least one route. Route consists of an handlers objects and list of guards (objects that implement Guard trait). Resources and routes uses builder-like pattern for configuration. During request handling, resource object iterate through all routes and check guards for specific route, if request matches all guards, route considered matched and route handler get called.

Examples

use actix_web::{web, App, HttpResponse};

let app = App::new().service(
    web::resource("/")
        .route(web::get().to(|| HttpResponse::Ok())));

If no matching route could be found, 405 response code get returned. Default behavior could be overridden with default_resource() method.

Implementations

impl Resource

pub fn new<T: IntoPatterns>(path: T) -> Resource

impl<T> Resource<T> where
    T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>, 

pub fn name(self, name: &str) -> Self

Set resource name.

Name is used for url generation.

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

Add match guard to a resource.

use actix_web::{web, guard, App, HttpResponse};

async fn index(data: web::Path<(String, String)>) -> &'static str {
    "Welcome!"
}

let app = App::new()
    .service(
        web::resource("/app")
            .guard(guard::Header("content-type", "text/plain"))
            .route(web::get().to(index))
    )
    .service(
        web::resource("/app")
            .guard(guard::Header("content-type", "text/json"))
            .route(web::get().to(|| HttpResponse::MethodNotAllowed()))
    );

pub fn route(self, route: Route) -> Self

Register a new route.

use actix_web::{web, guard, App, HttpResponse};

let app = App::new().service(
    web::resource("/").route(
        web::route()
            .guard(guard::Any(guard::Get()).or(guard::Put()))
            .guard(guard::Header("Content-Type", "text/plain"))
            .to(|| HttpResponse::Ok()))
);

Multiple routes could be added to a resource. Resource object uses match guards for route selection.

use actix_web::{web, guard, App};

let app = App::new().service(
    web::resource("/container/")
         .route(web::get().to(get_handler))
         .route(web::post().to(post_handler))
         .route(web::delete().to(delete_handler))
);

pub fn app_data<U: 'static>(self, data: U) -> Self

Add resource data.

Data of different types from parent contexts will still be accessible. Any Data<T> types set here can be extracted in handlers using the Data<T> extractor.

Examples

use std::cell::Cell;
use actix_web::{web, App, HttpRequest, HttpResponse, Responder};

struct MyData {
    count: std::cell::Cell<usize>,
}

async fn handler(req: HttpRequest, counter: web::Data<MyData>) -> impl Responder {
    // note this cannot use the Data<T> extractor because it was not added with it
    let incr = *req.app_data::<usize>().unwrap();
    assert_eq!(incr, 3);

    // update counter using other value from app data
    counter.count.set(counter.count.get() + incr);

    HttpResponse::Ok().body(counter.count.get().to_string())
}

let app = App::new().service(
    web::resource("/")
        .app_data(3usize)
        .app_data(web::Data::new(MyData { count: Default::default() }))
        .route(web::get().to(handler))
);

pub fn data<U: 'static>(self, data: U) -> Self

👎 Deprecated since 4.0.0:

Use .app_data(Data::new(val)) instead.

Add resource data after wrapping in Data<T>.

Deprecated in favor of app_data.

pub fn to<F, Args>(self, handler: F) -> Self where
    F: Handler<Args>,
    Args: FromRequest + 'static,
    F::Output: Responder + 'static, 

Register a new route and add handler. This route matches all requests.

use actix_web::{App, HttpRequest, HttpResponse, web};

async fn index(req: HttpRequest) -> HttpResponse {
    todo!()
}

App::new().service(web::resource("/").to(index));

This is shortcut for:

App::new().service(web::resource("/").route(web::route().to(index)));

pub fn wrap<M, B>(
    self,
    mw: M
) -> Resource<impl ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse<B>, Error = Error, InitError = ()>> where
    M: Transform<T::Service, ServiceRequest, Response = ServiceResponse<B>, Error = Error, InitError = ()> + 'static,
    B: MessageBody, 

Registers a resource middleware.

mw is a middleware component (type), that can modify the request and response across all routes managed by this Resource.

See App::wrap for more details.

pub fn wrap_fn<F, R, B>(
    self,
    mw: F
) -> Resource<impl ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse<B>, Error = Error, InitError = ()>> where
    F: Fn(ServiceRequest, &T::Service) -> R + Clone + 'static,
    R: Future<Output = Result<ServiceResponse<B>, Error>>,
    B: MessageBody, 

Registers a resource function middleware.

mw is a closure that runs during inbound and/or outbound processing in the request life-cycle (request -> response), modifying request/response as necessary, across all requests handled by the Resource.

See App::wrap_fn for examples and more details.

pub fn default_service<F, U>(self, f: F) -> Self where
    F: IntoServiceFactory<U, ServiceRequest>,
    U: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse, Error = Error> + 'static,
    U::InitError: Debug, 

Default service to be used if no matching route could be found.

You can use a Route as default service.

If a default service is not registered, an empty 405 Method Not Allowed response will be sent to the client instead. Unlike Scopes, a Resource does not inherit its parent’s default service.

Trait Implementations

impl<T, B> HttpServiceFactory for Resource<T> where
    T: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse<B>, Error = Error, InitError = ()> + 'static,
    B: MessageBody + 'static, 

fn register(self, config: &mut AppService)