Struct actix_web::App

pub struct App<S = ()> { /* fields omitted */ }

Structure that follows the builder pattern for building application instances.

Methods

impl App<()>

pub fn new() -> App<()>

Create application with empty state. Application can be configured with a builder-like pattern.

impl<S> App<S> where
    S: 'static, 

pub fn with_state(state: S) -> App<S>

Create application with specified state. Application can be configured with a builder-like pattern.

State is shared with all resources within same application and could be accessed with HttpRequest::state() method.

pub fn prefix<P: Into<String>>(self, prefix: P) -> App<S>

Set application prefix.

Only requests that match the application's prefix get processed by this application.

The application prefix always contains a leading slash (/). If the supplied prefix does not contain leading slash, it is inserted.

Prefix should consist of valid path segments. i.e for an application with the prefix /app any request with the paths /app, /app/ or /app/test would match, but the path /application would not.

In the following example only requests with an /app/ path prefix get handled. Requests with path /app/test/ would be handled, while requests with the paths /application or /other/... would return NOT FOUND.

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

fn main() {
    let app = App::new()
        .prefix("/app")
        .resource("/test", |r| {
             r.get().f(|_| HttpResponse::Ok());
             r.head().f(|_| HttpResponse::MethodNotAllowed());
        })
        .finish();
}

pub fn route<T, F, R>(self, path: &str, method: Method, f: F) -> App<S> where
    F: Fn(T) -> R + 'static,
    R: Responder + 'static,
    T: FromRequest<S> + 'static, 

Configure route for a specific path.

This is a simplified version of the App::resource() method. Handler functions need to accept one request extractor argument.

This method could be called multiple times, in that case multiple routes would be registered for same resource path.

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

fn main() {
    let app = App::new()
        .route("/test", http::Method::GET,
               |_: HttpRequest| HttpResponse::Ok())
        .route("/test", http::Method::POST,
               |_: HttpRequest| HttpResponse::MethodNotAllowed());
}

pub fn resource<F, R>(self, path: &str, f: F) -> App<S> where
    F: FnOnce(&mut ResourceHandler<S>) -> R + 'static, 

Configure resource for a specific path.

Resources may have variable path segments. For example, a resource with the path /a/{name}/c would match all incoming requests with paths such as /a/b/c, /a/1/c, or /a/etc/c.

A variable segment is specified in the form {identifier}, where the identifier can be used later in a request handler to access the matched value for that segment. This is done by looking up the identifier in the Params object returned by HttpRequest.match_info() method.

By default, each segment matches the regular expression [^{}/]+.

You can also specify a custom regex in the form {identifier:regex}:

For instance, to route GET-requests on any route matching /users/{userid}/{friend} and store userid and friend in the exposed Params object:

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

fn main() {
    let app = App::new()
        .resource("/test", |r| {
             r.get().f(|_| HttpResponse::Ok());
             r.head().f(|_| HttpResponse::MethodNotAllowed());
        });
}

pub fn default_resource<F, R>(self, f: F) -> App<S> where
    F: FnOnce(&mut ResourceHandler<S>) -> R + 'static, 

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

pub fn default_encoding<F>(self, encoding: ContentEncoding) -> App<S>

Set default content encoding. ContentEncoding::Auto is set by default.

pub fn external_resource<T, U>(self, name: T, url: U) -> App<S> where
    T: AsRef<str>,
    U: AsRef<str>, 

Register an external resource.

External resources are useful for URL generation purposes only and are never considered for matching at request time. Calls to HttpRequest::url_for() will work as expected.

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

fn index(mut req: HttpRequest) -> Result<HttpResponse> {
   let url = req.url_for("youtube", &["oHg5SJYRHA0"])?;
   assert_eq!(url.as_str(), "https://youtube.com/watch/oHg5SJYRHA0");
   Ok(HttpResponse::Ok().into())
}

fn main() {
    let app = App::new()
        .resource("/index.html", |r| r.get().f(index))
        .external_resource("youtube", "https://youtube.com/watch/{video_id}")
        .finish();
}

pub fn handler<H: Handler<S>>(self, path: &str, handler: H) -> App<S>

Configure handler for specific path prefix.

A path prefix consists of valid path segments, i.e for the prefix /app any request with the paths /app, /app/ or /app/test would match, but the path /application would not.

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

fn main() {
    let app = App::new()
        .handler("/app", |req: HttpRequest| {
            match *req.method() {
                http::Method::GET => HttpResponse::Ok(),
                http::Method::POST => HttpResponse::MethodNotAllowed(),
                _ => HttpResponse::NotFound(),
        }});
}

pub fn middleware<M: Middleware<S>>(self, mw: M) -> App<S>

Register a middleware.

pub fn configure<F>(self, cfg: F) -> App<S> where
    F: Fn(App<S>) -> App<S>, 

Run external configuration as part of the application building process

This function is useful for moving parts of configuration to a different module or event library. For example we can move some of the resources' configuration to different module.

use actix_web::{App, HttpResponse, fs, middleware};

// this function could be located in different module
fn config(app: App) -> App {
    app
        .resource("/test", |r| {
             r.get().f(|_| HttpResponse::Ok());
             r.head().f(|_| HttpResponse::MethodNotAllowed());
        })
}

fn main() {
    let app = App::new()
        .middleware(middleware::Logger::default())
        .configure(config)  // <- register resources
        .handler("/static", fs::StaticFiles::new("."));
}

pub fn finish(&mut self) -> HttpApplication<S>

Finish application configuration and create HttpHandler object.

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn boxed(self) -> Box<HttpHandler>

Convenience method for creating Box<HttpHandler> instances.

This method is useful if you need to register multiple application instances with different state.

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

struct State1;

struct State2;

fn main() {
    server::new(|| { vec![
        App::with_state(State1)
             .prefix("/app1")
             .resource("/", |r| r.f(|r| HttpResponse::Ok()))
             .boxed(),
        App::with_state(State2)
             .prefix("/app2")
             .resource("/", |r| r.f(|r| HttpResponse::Ok()))
             .boxed() ]})
        .bind("127.0.0.1:8080").unwrap()
        .run()
}

Trait Implementations

impl Default for App<()>

fn default() -> Self

Returns the "default value" for a type.

impl<S: 'static> IntoHttpHandler for App<S>

type Handler = HttpApplication<S>

The associated type which is result of conversion.

fn into_handler(self, settings: ServerSettings) -> HttpApplication<S>

Convert into HttpHandler object.

impl<'a, S: 'static> IntoHttpHandler for &'a mut App<S>

type Handler = HttpApplication<S>

The associated type which is result of conversion.

fn into_handler(self, settings: ServerSettings) -> HttpApplication<S>

Convert into HttpHandler object.