Serialización y deserialización de JSON con Rust

JSON (Notación de objetos de JavaScript) se ha convertido en un formato popular de intercambio de datos en el software. desarrollo debido a su simplicidad, legibilidad y soporte generalizado en varias programaciones idiomas JSON es una alternativa ligera a XML para transmitir datos entre un servidor y una aplicación web o entre diferentes componentes del sistema de software.

Uno de los aspectos clave de trabajar con JSON es el proceso de serialización y deserialización que le permite convertir datos JSON en un formato estructurado que puede manipular fácilmente dentro de su programas La mayoría de las veces, si desea trabajar con JSON en otros idiomas, es posible que deba serializar y deserializar los datos JSON en las estructuras de datos integradas del idioma.

Primeros pasos con Serde

Serde (serialización y deserialización) es una biblioteca de Rust ampliamente utilizada que proporciona un marco para convertir

Estructuras de datos oxidadas en formatos para almacenamiento, transmisión, intercambio y otros.

Serde permite una conversión perfecta entre los tipos de datos de Rust y varios formatos de intercambio de datos, incluidos JSON, YAML, BSON, CBOR, MessagePack y otros.

El enfoque principal de Serde es hacer que el proceso de serialización y deserialización sea lo más simple y eficiente posible, al mismo tiempo que se mantienen funciones sólidas de escritura y seguridad.

Agregue estas directivas al dependencias sección de su Cargo.toml archivo para instalar y usar Serde como un dependencia de terceros con Cargo.

[dependencias]
serde = { versión = "1.0.159", caracteristicas = ["derivar"] }
serde_json = "1.0.96"

Necesitarás tanto el serde y serde_json cajas para interactuar con JSON. El serde crate proporciona las funcionalidades básicas, y el serde_json crate es una implementación específica de Serde para trabajar con JSON.

Así es como puede importar el serde_json caja y el Fabricar en serie y deserializar módulos de la serde caja:

usar serde::{Serializar, Deserializar};
usar serde_json;

En general, Serde es una herramienta poderosa que necesitará en su arsenal de desarrollo si está trabajando con JSON en Rust.

Serialización de datos con Serde

El proceso de serialización JSON implica convertir un tipo Rust (personalizado o integrado) a JSON para otras operaciones. Serde proporciona un conjunto de atributos que puede usar con Rust struct para permitir un control preciso sobre el proceso de serialización, incluido el #[derivar (Serializar)] atributo que le permite generar código de serialización para sus estructuras de datos y convertir su estructura Rust a JSON.

Considere esta estructura que representa los datos biológicos de una persona; así es como puede importar y usar el Fabricar en serie atributo en la estructura:

usar serde::{Serializar, Deserializar};
usar serde_json;
#[derivar (Serializar)]
estructuraPersona {
 nombre: Cadena,
 edad: u32,
}

Al anotar el Persona estructura con el [#derive (Serializar)], le está diciendo a Serde que genere el código de serialización necesario para el Persona estructura automáticamente.

Así es como puede serializar una instancia del Persona estructura a JSON:

usar serde::{Serializar};
usar serde_json;
fnprincipal() {
// declaración de la instancia de la estructura Person con los campos de nombre y edad
dejar persona = Persona {
 nombre: "Chukwuemeriwo".Encadenar(),
 edad: 28,
 };
// serializa la estructura de persona a JSON utilizando la biblioteca serde_json
dejar json = serde_json:: to_string(&person).expect("Serialización fallida");
// imprime la cadena JSON serializada
imprimir!("JSON serializado: {}", json);
}

En el principal función, la serde_json crate serializa el persona objeto. El Encadenar La función toma una referencia a la persona objeto y devuelve una cadena JSON que representa los datos serializados.

Finalmente, el principal La función imprime el JSON serializado en la consola.

El serde y serde_json son versátiles, también puede serializar arreglos con serde.

usar serde::{Serializar, Deserializar};
usar serde_json;
#[derivar (Serializar)]
estructuraCoordenadas {
 X: f32,
 y: f32,
}
fnprincipal() {
dejar puntos = vec![ 
 Coordenadas X: 1.0, y: 2.0 },
 Coordenadas X: 3.5, y: 4.5 },
 ];
dejar json = serde_json:: to_string(&points).expect("Serialización fallida"); 
imprimir!("JSON serializado: {}", json); // Imprime la cadena JSON serializada
}

El puntos variable es un vector de Coordenadas Estructuras que representan puntos en un plano. Aplicando el Fabricar en serie atribuir a la Coordenadas struct le permite serializar el vector a JSON sin esfuerzo.

Además, puede serializar enumeraciones en JSON con serde como usted serializa estructuras y vectores.

usar serde::{Serializar, Deserializar};
usar serde_json;
#[derivar (Serializar, Deserializar)]
enumeraciónAnimal {
 Perro(Cadena),
 Gato(u32),
 Pájaro,
}
fnprincipal() {
dejar perro = Animal:: Perro("Oxidado".Encadenar());
dejar json = serde_json:: to_string(&dog).expect("Serialización fallida");
imprimir!("JSON serializado: {}", json);
}

Dependiendo de la variante, el proceso de serialización se adapta en consecuencia (en este caso, el Animal:: Perro variante incluye un Cadena campo que Serde serializará como una cadena JSON).

Deserialización de datos con Serde

La deserialización JSON es el proceso de transformar datos JSON en tipos de datos nativos de un lenguaje de programación. Serde proporciona un marco integral para la deserialización de JSON que funciona en la mayoría de los tipos de datos integrados.

Similar a la serialización, Serde ofrece atributos que puede usar para anotar sus estructuras de Rust para el proceso de deserialización. Dos atributos comúnmente utilizados para la serialización son el #[derivar (Deserializar)] y #[serde (renombrar = "json_field_name")] atributos

El #[derivar (Deserializar)] El atributo deriva automáticamente la implementación de deserialización para su Tipos de estructura de óxido, mientras que la #[serde (renombrar = "json_field_name")] El atributo le permite asignar campos de estructura a los nombres de campo JSON correspondientes.

Así es como puede deserializar datos JSON en un tipo de estructura personalizada con Serde:

usar serde:: Deserializar;
usar serde_json;
// define una estructura para Person con el rasgo Deserialize de Serde
#[derivar (Deserializar)]
estructuraPersona {
#[serde (renombrar = "nombre")]// cambia el nombre del campo a "nombre" 
 nombre completo: Cadena, 
 edad: u32,
}
fnprincipal() {
dejar json_data = r#"
 {
"nombre": "Juan Doe",
"edad": 30
 }
"#;
// deserializa los datos JSON en una estructura de persona 
dejar persona: Persona = serde_json:: from_str (json_data).unwrap();
// Escriba el nombre completo y la edad de la persona
imprimir!("Nombre: {}", persona.nombre_completo);
imprimir!("Edad: {}", persona.edad);
}

Al anotar el Persona estructura con el #[derivar (Deserializar)] atributo, indica que Serde puede deserializar la estructura de JSON. El #[serde (renombrar = "nombre")] atributo mapea el nombre campo en el JSON al nombre completo campo.

El from_str función deserializa el datos_json variable en el persona objeto, y el principal La función imprime los campos en la consola.

Serde admite la deserialización en varios tipos de datos de Rust, incluidos tipos primitivos, enumeraciones, estructuras anidadas y colecciones.

Así es como puede deserializar una matriz JSON en una estructura Rust que contiene un campo vectorial:

usar serde:: Deserializar;
#[derivar (Deserializar)]
estructuraDatos {
 números: Vec<u32>,
}
fnprincipal() {
dejar json_data = r#"
 {
"números": [1, 2, 3, 4, 5]
 }
"#;
dejar datos: Datos = serde_json:: from_str (json_data).unwrap();
para número en datos.numeros {
imprimir!("Número: {}", número);
 }
}

El principal función deserializa el datos_json contenido JSON en el datos variable, y el ciclo imprime los elementos en el vector.

Debe asegurarse de tener los tipos de datos e identificadores correctos para un proceso de deserialización.

Serde interactúa con los marcos web populares de Rust

Serde es una biblioteca poderosa con muchas funciones y una API simple para serializar y deserializar datos en diferentes formatos.

Serde es ampliamente adoptado en el ecosistema de Rust, y muchas cajas y marcos populares tienen incorporado soporte para Serde, incluidos marcos web populares como Actix, Warp y Rocket y ORM de base de datos como Diesel.