Forget about stringly typed objects, from request to response, everything has types.
Actix provides a lot of features out of box. HTTP/2, logging, etc.
Easily create your own libraries that any Actix application can use.
Actix is blazingly fast. Don't take our word for it -- see for yourself!
use actix_web::{web, App, HttpRequest, HttpServer, Responder};
async fn greet(req: HttpRequest) -> impl Responder {
let name = req.match_info().get("name").unwrap_or("World");
format!("Hello {}!", &name)
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.route("/", web::get().to(greet))
.route("/{name}", web::get().to(greet))
})
.bind(("127.0.0.1", 8080))?
.run()
.await
}
Handler functions in actix can return a wide range of objects that
implement the Responder
trait. This makes it a breeze
to return consistent responses from your APIs.
#[derive(Serialize)]
struct Measurement {
temperature: f32,
}
async fn hello_world() -> impl Responder {
"Hello World!"
}
async fn current_temperature() -> impl Responder {
web::Json(Measurement { temperature: 42.3 })
}
Actix comes with a powerful extractor system that extracts data from the incoming HTTP request and passes it to your view functions. Not only does this make for a convenient API but it also means that your view functions can be synchronous code and still benefit from asynchronous IO handling.
#[derive(Deserialize, Serialize)]
struct Event {
id: Option<i32>,
timestamp: f64,
kind: String,
tags: Vec<String>,
}
async fn capture_event(evt: web::Json<Event>) -> impl Responder {
let new_event = store_in_db(evt.timestamp, &evt.kind, &evt.tags);
format!("got event {}", new_event.id.unwrap())
}
Handling multipart/urlencoded form data is easy. Just define a structure that can be deserialized and actix will handle the rest.
#[derive(Deserialize)]
struct Register {
username: String,
country: String,
}
async fn register(form: web::Form<Register>) -> impl Responder {
format!("Hello {} from {}!", form.username, form.country)
}
An actix app comes with a URL routing system that lets you match on URLs and invoke individual handlers. For extra flexibility, scopes can be used.
#[get("/")]
async fn index(_req: HttpRequest) -> impl Responder {
"Hello from the index page!"
}
async fn hello(path: web::Path<String>) -> impl Responder {
format!("Hello {}!", &path)
}
let app = App::new()
.service(index)
.route("/{name}", web::get().to(hello));