pub struct App<S = ()> { /* private fields */ }
Expand description
Structure that follows the builder pattern for building application instances.
Implementations
sourceimpl<S> App<S>where
S: 'static,
impl<S> App<S>where
S: 'static,
sourcepub fn with_state(state: S) -> App<S>
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.
Note: http server accepts an application factory rather than
an application instance. Http server constructs an application
instance for each thread, thus application state must be constructed
multiple times. If you want to share state between different
threads, a shared object should be used, e.g. Arc
. Application
state does not need to be Send
or Sync
.
sourcepub fn prefix<P: Into<String>>(self, prefix: P) -> App<S>
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
. It is also possible to
handle /app
path, to do this you can register resource for
empty string ""
use actix_web::{http, App, HttpResponse};
fn main() {
let app = App::new()
.prefix("/app")
.resource("", |r| r.f(|_| HttpResponse::Ok())) // <- handle `/app` path
.resource("/", |r| r.f(|_| HttpResponse::Ok())) // <- handle `/app/` path
.resource("/test", |r| {
r.get().f(|_| HttpResponse::Ok());
r.head().f(|_| HttpResponse::MethodNotAllowed());
})
.finish();
}
sourcepub fn filter<T: Predicate<S> + 'static>(self, p: T) -> App<S>
pub fn filter<T: Predicate<S> + 'static>(self, p: T) -> App<S>
Add match predicate to application.
App::new()
.filter(pred::Host("www.rust-lang.org"))
.resource("/path", |r| r.f(|_| HttpResponse::Ok()))
sourcepub fn route<T, F, R>(self, path: &str, method: Method, f: F) -> App<S>where
F: WithFactory<T, S, R>,
R: Responder + 'static,
T: FromRequest<S> + 'static,
pub fn route<T, F, R>(self, path: &str, method: Method, f: F) -> App<S>where
F: WithFactory<T, S, R>,
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()
});
}
sourcepub fn scope<F>(self, path: &str, f: F) -> App<S>where
F: FnOnce(Scope<S>) -> Scope<S>,
pub fn scope<F>(self, path: &str, f: F) -> App<S>where
F: FnOnce(Scope<S>) -> Scope<S>,
Configure scope for common root path.
Scopes collect multiple paths under a common path prefix. Scope path can contain variable path segments as resources.
use actix_web::{http, App, HttpRequest, HttpResponse};
fn main() {
let app = App::new().scope("/{project_id}", |scope| {
scope
.resource("/path1", |r| r.f(|_| HttpResponse::Ok()))
.resource("/path2", |r| r.f(|_| HttpResponse::Ok()))
.resource("/path3", |r| r.f(|_| HttpResponse::MethodNotAllowed()))
});
}
In the above example, three routes get added:
- /{project_id}/path1
- /{project_id}/path2
- /{project_id}/path3
sourcepub fn resource<F, R>(self, path: &str, f: F) -> App<S>where
F: FnOnce(&mut Resource<S>) -> R + 'static,
pub fn resource<F, R>(self, path: &str, f: F) -> App<S>where
F: FnOnce(&mut Resource<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("/users/{userid}/{friend}", |r| {
r.get().f(|_| HttpResponse::Ok());
r.head().f(|_| HttpResponse::MethodNotAllowed());
});
}
sourcepub fn default_resource<F, R>(self, f: F) -> App<S>where
F: FnOnce(&mut Resource<S>) -> R + 'static,
pub fn default_resource<F, R>(self, f: F) -> App<S>where
F: FnOnce(&mut Resource<S>) -> R + 'static,
Default resource to be used if no matching route could be found.
sourcepub fn default_encoding(self, encoding: ContentEncoding) -> App<S>
pub fn default_encoding(self, encoding: ContentEncoding) -> App<S>
Set default content encoding. ContentEncoding::Auto
is set by default.
sourcepub fn external_resource<T, U>(self, name: T, url: U) -> App<S>where
T: AsRef<str>,
U: AsRef<str>,
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(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();
}
sourcepub fn handler<H: Handler<S>>(self, path: &str, handler: H) -> App<S>
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.
Path tail is available as tail
parameter in request’s match_dict.
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(),
});
}
sourcepub fn middleware<M: Middleware<S>>(self, mw: M) -> App<S>
pub fn middleware<M: Middleware<S>>(self, mw: M) -> App<S>
Register a middleware.
sourcepub fn configure<F>(self, cfg: F) -> App<S>where
F: Fn(App<S>) -> App<S>,
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::{fs, middleware, App, HttpResponse};
// 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(".").unwrap());
}
sourcepub fn finish(&mut self) -> HttpApplication<S>
pub fn finish(&mut self) -> HttpApplication<S>
Finish application configuration and create HttpHandler
object.
sourcepub fn boxed(self) -> Box<dyn HttpHandler<Task = Box<dyn HttpHandlerTask>>>
pub fn boxed(self) -> Box<dyn HttpHandler<Task = Box<dyn HttpHandlerTask>>>
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
sourceimpl<'a, S: 'static> IntoHttpHandler for &'a mut App<S>
impl<'a, S: 'static> IntoHttpHandler for &'a mut App<S>
type Handler = HttpApplication<S>
type Handler = HttpApplication<S>
sourcefn into_handler(self) -> HttpApplication<S>
fn into_handler(self) -> HttpApplication<S>
HttpHandler
object.sourceimpl<S: 'static> IntoHttpHandler for App<S>
impl<S: 'static> IntoHttpHandler for App<S>
type Handler = HttpApplication<S>
type Handler = HttpApplication<S>
sourcefn into_handler(self) -> HttpApplication<S>
fn into_handler(self) -> HttpApplication<S>
HttpHandler
object.Auto Trait Implementations
impl<S = ()> !RefUnwindSafe for App<S>
impl<S = ()> !Send for App<S>
impl<S = ()> !Sync for App<S>
impl<S> Unpin for App<S>where
S: Unpin,
impl<S = ()> !UnwindSafe for App<S>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
sourceimpl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
sourcefn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
sourcefn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
sourceimpl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
sourcefn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
choose
or choose_mut
functions using the slice instead. Read more