43 - Integrando crates externos - serialización y peticiones http en Rust

¡Bienvenidos de nuevo a Rustaceo.es! Hoy aprenderemos a integrar crates externos para manejar serialización de datos y peticiones HTTP. Estas herramientas son esenciales para interactuar con APIs, procesar datos y construir aplicaciones conectadas a la web.

🚀 ¿Por qué usar crates externos? #

Rust es un lenguaje minimalista, pero su ecosistema de crates nos permite ampliar su funcionalidad. Algunas de las tareas más comunes que requieren crates externos incluyen: ✔ Serialización y deserialización de datos (JSON, TOML, YAML). ✔ Realizar peticiones HTTP a APIs. ✔ Manejo de concurrencia y asincronía.

🏗 Instalando y configurando dependencias #

Para utilizar crates externos, los agregamos en Cargo.toml.

📌 Ejemplo: Añadiendo serde para serialización y reqwest para peticiones HTTP

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }

Luego, ejecutamos:

cargo check

para asegurarnos de que las dependencias están correctamente configuradas.

🔄 Serialización y deserialización con serde #

serde nos permite convertir estructuras de Rust a JSON y viceversa.

📌 Ejemplo: serializar una estructura en json #

use serde::{Serialize, Deserialize};
use serde_json;

#[Derive(serialize, deserialize, debug)]
struct Pokémon {
    nombre: String,
    tipo: String,
    nivel: u8,
}

fn main() {
    let item1 = Pokémon {
        nombre: "Item1".to_string(),
        tipo: "Eléctrico".to_string(),
        nivel: 25,
    };
    
    let json = serde_json::to_string(&item1).unwrap();
    println!("JSON generado: {}", json);
}

✔ serde_json::to_string() convierte la estructura en una cadena JSON. ✔ #[derive(Serialize, Deserialize)] permite a serde manejar la estructura automáticamente.

📌 Ejemplo: deserializar json a una estructura #

let json_data = '{"nombre": "Item2", "tipo": "Fuego", "nivel": 10}';
let item2: Pokémon = serde_json::from_str(json_data).unwrap();
println!("Deserializado: {:?}", item2);

✔ serde_json::from_str() convierte un JSON en una estructura de Rust.

🌐 Realizando peticiones http con reqwest #

Para interactuar con APIs, utilizamos reqwest, que nos permite hacer peticiones GET y POST.

📌 Ejemplo: hacer una petición get a una api #

use reqwest;

#[Tokio::main]
async fn main() {
    let respuesta = reqwest::get("https://pokeapi.co/api/v2/pokemon/1")
        .await.unwrap()
        .text()
        .await.unwrap();
    println!("Respuesta: {}", respuesta);
}

✔ reqwest::get() envía una solicitud HTTP GET. ✔ .await permite manejar la respuesta asincrónicamente. ✔ tokio::main ejecuta la función principal en un runtime asíncrono.

📌 Ejemplo: enviar datos con una petición post #

use reqwest::Client;
use serde_json::json;

#[Tokio::main]
async fn main() {
    let cliente = Client::new();
    let respuesta = cliente.post("https://example.com/api")
        .json(&json!({"nombre": "Item4", "tipo": "Planta"}))
        .send()
        .await.unwrap()
        .text()
        .await.unwrap();
    
    println!("Respuesta del servidor: {}", respuesta);
}

✔ Client::new().post() crea una solicitud HTTP POST. ✔ .json(&json!({...})) convierte datos en JSON automáticamente. ✔ .send().await.unwrap() envía la solicitud y obtiene la respuesta.

🏆 Conclusión #

Integrar crates externos como serde y reqwest nos permite manejar serialización de datos y comunicación con APIs de manera eficiente.

🎯 Resumen de lo aprendido: ✔ serde convierte estructuras de Rust en JSON y viceversa. ✔ reqwest permite hacer peticiones HTTP asíncronas. ✔ tokio facilita la ejecución asincrónica en Rust.

🔮 Próximo paso: Explora cómo combinar estos crates para construir APIs REST en Rust.

¡Hasta la próxima, Rustaceos!