Resumen de Actix-Web.

Actix-Web es un marco de trabajo web poderoso y eficiente para construir aplicaciones web con Rust. Está construido sobre el marco de actores Actix, que proporciona una base ligera y asíncrona para construir aplicaciones altamente concurrentes y escalables.

Actix-Web se enfoca en el rendimiento, la simplicidad y la flexibilidad, lo que lo convierte en una excelente opción para desarrollar aplicaciones web tanto pequeñas como a gran escala. Aprovecha el sólido sistema de tipos y la seguridad de memoria de Rust para garantizar la solidez y confiabilidad en tu código.

Historia

Actix-Web fue lanzado por primera vez en 2017 y desde entonces ha ganado popularidad dentro de la comunidad de Rust. Fue desarrollado por Nikolay Kim y otros colaboradores como una extensión del marco de actores Actix. Actix rápidamente se convirtió en uno de los marcos de trabajo de Rust más populares debido a su rendimiento y escalabilidad, y Actix-Web se basa en estas fortalezas para proporcionar una solución completa de desarrollo web.

Características

Actix-Web ofrece varias características clave que lo convierten en una opción poderosa para el desarrollo web:

Asincrónico y sin bloqueo: Actix-Web está construido en torno a la programación asíncrona, lo que te permite manejar un gran número de conexiones concurrentes sin bloquear la ejecución de otras solicitudes. Esto permite aplicaciones de alto rendimiento y escalables.

Soporte de middleware: Actix-Web proporciona un sistema de middleware que te permite agregar componentes reutilizables a la tubería de solicitud-respuesta. El middleware se puede utilizar para tareas como autenticación, registro, compresión y más. Aquí tienes un ejemplo de cómo agregar middleware a una aplicación de Actix-Web:

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

async fn index() -> HttpResponse {
    HttpResponse::Ok().body("¡Hola, Actix-Web!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(middleware::Logger::default())
            .service(web::resource("/").to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

En este ejemplo, agregamos el middleware Logger, que registra información sobre las solicitudes entrantes.

Enrutamiento: Actix-Web proporciona un sistema de enrutamiento flexible e intuitivo que te permite definir rutas y manejar diferentes métodos HTTP y parámetros de ruta. Aquí tienes un ejemplo de cómo definir rutas en Actix-Web:

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

async fn index() -> HttpResponse {
    HttpResponse::Ok().body("¡Hola, Actix-Web!")
}

async fn hello(name: web::Path<String>) -> HttpResponse {
    HttpResponse::Ok().body(format!("¡Hola, {}!", name))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/hello/{name}", web::get().to(hello))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

En este ejemplo, definimos dos rutas: / y /hello/{name}. La primera ruta maneja una solicitud básica GET, mientras que la segunda ruta maneja una solicitud GET con un parámetro de ruta.

Manejo de solicitudes: Actix-Web proporciona un sistema de manejo de solicitudes potente y flexible. Puedes extraer fácilmente datos de las solicitudes, como los parámetros de consulta, los parámetros de ruta y los cuerpos de las solicitudes. Aquí tienes un ejemplo que muestra cómo extraer parámetros de consulta y cuerpos de solicitudes:

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

async fn index(req: HttpRequest) -> HttpResponse {
    let name = req.query_string();
    HttpResponse::Ok().body(format!("¡Hola, {}!", name))
}

async fn hello(info: web::Json<HelloInfo>) -> HttpResponse {
    let message = format!("¡Hola, {}!", info.name);
    HttpResponse::Ok().json(HelloResponse { message })
}

#[derive(serde::Serialize, serde::Deserialize)]
struct HelloInfo {
    name: String,
}

#[derive(serde::Serialize)]
struct HelloResponse {
    message: String,
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/hello", web::post().to(hello))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

En este ejemplo, el controlador index extrae el parámetro de consulta name de la solicitud y responde con un saludo personalizado. El controlador hello extrae una carga útil JSON del cuerpo de la solicitud y responde con una carga útil JSON que contiene un saludo personalizado.

Soporte de pruebas: Actix-Web proporciona un marco de pruebas que te permite escribir pruebas unitarias para tu aplicación web. Ofrece utilidades para simular solicitudes HTTP y hacer afirmaciones sobre las respuestas. Aquí tienes un ejemplo de una prueba simple para una aplicación de Actix-Web:

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

async fn index() -> HttpResponse {
    HttpResponse::Ok().body("¡Hola, Actix-Web!")
}

#[actix_rt::test]
async fn test_index() {
    let app = App::new().route("/", web::get().to(index));
    let mut srv = test::init_service(app).await;

    let req = test::TestRequest::get().uri("/").to_request();
    let resp = test::call_service(&mut srv, req).await;

    assert!(resp.status().is_success());
    let body = test::read_body(resp).await;
    assert_eq!(body, "¡Hola, Actix-Web!");
}

En este ejemplo, escribimos una prueba para el controlador index. Inicializamos el servicio de prueba, creamos una solicitud GET a la ruta raíz y afirmamos que el estado de la respuesta es exitoso y el cuerpo de la respuesta coincide con el valor esperado.

Ejemplos

Para demostrar el uso de Actix-Web, aquí tienes algunos ejemplos:

Hola Mundo:

El siguiente ejemplo muestra una aplicación simple de Actix-Web que responde con "¡Hola, mundo!" para todas las solicitudes a la ruta raíz ("/").

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

async fn index() -> HttpResponse {
    HttpResponse::Ok().body("¡Hola, mundo!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Parámetros de consulta:

Este ejemplo muestra cómo manejar parámetros de consulta en Actix-Web. Responde con un saludo personalizado basado en el parámetro de consulta "name".

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

async fn index(request: web::HttpRequest) -> HttpResponse {
    let name = request.query().get("name").unwrap_or("Anónimo");
    HttpResponse::Ok().body(format!("¡Hola, {}!", name))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

WebSockets:

Este ejemplo muestra cómo manejar conexiones WebSocket en Actix-Web. Establece una conexión WebSocket y maneja mensajes entrantes y salientes.

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

async fn ws_index(request: web::HttpRequest) -> impl Responder {
    actix_web::web::WebSocket::new(request)
        .await
        .unwrap()
        .on_upgrade(|websocket| {
            // Lógica de la conexión WebSocket
            actix_rt::spawn(async move {
                // Manejar mensajes entrantes y salientes
            })
        })
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/ws/", web::get().to(ws_index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .
<!-- d -->

Resumen de Actix-Web.

Historia​

Características​

Ejemplos​

Historia

Características

Ejemplos