actix/actix-website
1
0
Fork 0
mirror of https://github.com/actix/actix-website synced 2025-01-22 16:15:56 +01:00
Code Issues Releases Wiki Activity

update extractors

Browse Source
This commit is contained in:
Nikolay Kim 2020-01-02 18:33:33 +06:00
parent 4046b0b697
commit b8e2a2310c
8 changed files with 42 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
content/docs/extractors.md
View File

@ -9,18 +9,11 @@ weight: 170
Actix-web provides a facility for type-safe request information access called *extractors*
(ie, `impl FromRequest`). By default, actix-web provides several extractor implementations.
## Extractors Within Handler Functions
An extractor can be accessed in a few different ways.
Option 1 - passed as a parameter to a handler function:
An extractor can be accessed as an arguments to a handler function. Actix-web supports
up to 10 extractors per handler function. Argument position does not matter.
{{< include-example example="extractors" file="main.rs" section="option-one" >}}
Option 2 - accessed by calling `extract()` on the Extractor
{{< include-example example="extractors" file="main.rs" section="option-two" >}}
# Path
[*Path*][pathstruct] provides information that can be extracted from the Request's
@ -78,15 +71,6 @@ the *serde* crate.
{{< include-example example="extractors" file="form.rs" section="form" >}}
# Multiple extractors
Actix-web provides extractor implementations for tuples (up to 10 elements) whose
elements implement `FromRequest`.
For example we can use a path extractor and a query extractor at the same time.
{{< include-example example="extractors" file="multiple.rs" section="multi" >}}
# Other
Actix-web also provides several other extractors:
@ -102,7 +86,7 @@ Actix-web also provides several other extractors:
* *Payload* - You can access a request's payload.
[*Example*][payloadexample]
# Async Data Access
# Application state extractor
Application state is accessible from the handler with the `web::Data` extractor;
however, state is accessible as a read-only reference. If you need mutable access to state,
@ -125,7 +109,7 @@ number of requests processed per thread. A proper implementation would use `Arc`
> Be careful with synchronization primitives like `Mutex` or `RwLock`. The `actix-web` framework
> handles requests asynchronously. By blocking thread execution, all concurrent
> request handling processes would block. If you need to share or update some state
> from multiple threads, consider using the [actix][actix] actor system.
> from multiple threads, consider using the tokio synchronization primitives.
[pathstruct]: https://docs.rs/actix-web/2/actix_web/dev/struct.Path.html
[querystruct]: https://docs.rs/actix-web/2/actix_web/web/struct.Query.html

2
content/docs/response.md
View File

@ -66,7 +66,7 @@ negotiation.
# JSON Response
The `Json` type allows to respond with well-formed JSON data: simply return a value of
type Json<T> where `T` is the type of a structure to serialize into *JSON*.
type `Json<T>` where `T` is the type of a structure to serialize into *JSON*.
The type `T` must implement the `Serialize` trait from *serde*.
{{< include-example example="responses" file="json_resp.rs" section="json-resp" >}}

24
examples/extractors/src/json_two.rs
View File

@ -19,19 +19,17 @@ async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new().service(
web::resource("/")
.data(
// change json extractor configuration
web::Json::<Info>::configure(|cfg| {
cfg.limit(4096).error_handler(|err, _req| {
// <- create custom error response
error::InternalError::from_response(
err,
HttpResponse::Conflict().finish(),
)
.into()
})
}),
)
// change json extractor configuration
.app_data(web::Json::<Info>::configure(|cfg| {
cfg.limit(4096).error_handler(|err, _req| {
// create custom error response
error::InternalError::from_response(
err,
HttpResponse::Conflict().finish(),
)
.into()
})
}))
.route(web::post().to(index)),
)
})

4
examples/extractors/src/multiple.rs
View File

@ -7,7 +7,9 @@ struct Info {
username: String,
}
async fn index((path, query): (web::Path<(u32, String)>, web::Query<Info>)) -> String {
async fn index(
(path, query): (web::Path<(u32, String)>, web::Query<Info>),
) -> String {
format!(
"Welcome {}, friend {}, userid {}!",
query.username, path.1, path.0

3
examples/extractors/src/path_three.rs
View File

@ -2,7 +2,8 @@ use actix_web::{web, HttpRequest, Result};
// <path-three>
async fn index(req: HttpRequest) -> Result<String> {
let name: String = req.match_info().get("friend").unwrap().parse().unwrap();
let name: String =
req.match_info().get("friend").unwrap().parse().unwrap();
let userid: i32 = req.match_info().query("userid").parse().unwrap();
Ok(format!("Welcome {}, userid {}!", name, userid))

2
examples/request-handlers/src/handlers_arc.rs
View File

@ -28,7 +28,7 @@ async fn main() -> std::io::Result<()> {
HttpServer::new(move || {
App::new()
.data(data.clone())
.app_data(data.clone())
.route("/", web::to(show_count))
.route("/add", web::to(add_one))
})

2
examples/request-handlers/src/main.rs
View File

@ -29,7 +29,7 @@ async fn main() -> std::io::Result<()> {
HttpServer::new(move || {
App::new()
.data(data.clone())
.app_data(data.clone())
.route("/", web::to(show_count))
.route("/add", web::to(add_one))
})

39
examples/responses/src/chunked.rs
View File

@ -1,23 +1,22 @@
// // <chunked>
// use actix_web::{web, HttpRequest, HttpResponse};
// use bytes::Bytes;
// use futures::stream::once;
// <chunked>
use actix_web::{web, HttpRequest, HttpResponse};
use bytes::Bytes;
use futures::future::ok;
use futures::stream::once;
// fn index(req: HttpRequest) -> HttpResponse {
// HttpResponse::Ok()
// .chunked()
// .body(Body::Streaming(Box::new(once(Ok(Bytes::from_static(
// b"data",
// ))))))
// }
// // </chunked>
async fn index(req: HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.chunked()
.streaming(once(ok::<_, Error>(Bytes::from_static(b"data"))))
}
// </chunked>
// pub fn main() {
// use actix_web::{web, App, HttpServer};
pub fn main() {
use actix_web::{web, App, HttpServer};
// HttpServer::new(|| App::new().route("/", web::get().to(index)))
// .bind("127.0.0.1:8088")
// .unwrap()
// .run()
// .unwrap();
// }
HttpServer::new(|| App::new().route("/", web::get().to(index)))
.bind("127.0.0.1:8088")
.unwrap()
.run()
.unwrap();
}