Réponse

Dans un Handler, la Response est passée en paramètre :

La structure Response encapsule tous les composants d'une réponse HTTP, offrant une API complète pour construire et manipuler les réponses HTTP.
Elle prend en charge un style fluide et chaînable (par exemple, res.status_code(200).body("Hello")), facilitant la construction fluide des réponses.
Les fonctionnalités principales incluent :
- La définition des codes d'état et des en-têtes
- La manipulation du corps de la réponse (prise en charge des chaînes de caractères, des octets, des fichiers et des données en flux)
- La gestion des cookies
- Plusieurs méthodes de rendu de contenu
Cette structure utilise un modèle de référence mutable, renvoyant une référence à elle-même via &mut self, permettant aux gestionnaires de construire et personnaliser facilement les réponses HTTP pour répondre à diverses exigences de services web.

#[handler]
async fn hello_world(res: &mut Response) {
    res.render("Hello world!");
}

Après que le serveur reçoit une requête client, tout Handler ou middleware correspondant peut écrire des données dans la Response. Dans certains scénarios, comme lorsqu'un middleware souhaite empêcher l'exécution des middlewares et Handler suivants, vous pouvez utiliser FlowCtrl :

#[handler]
async fn hello_world(res: &mut Response, ctrl: &mut FlowCtrl) {
    ctrl.skip_rest();
    res.render("Hello world!");
}

Écriture de contenu

Écrire des données dans une Response est simple :

Écrire des données en texte brut
```
res.render("Hello world!");
```

Écrire des données sérialisées en JSON

use serde::Serialize;
use salvo::prelude::Json;

#[derive(Serialize, Debug)]
struct User {
    name: String,
}
let user = User{name: "jobs".to_string()};
res.render(Json(user));

Warning

Si la méthode render est appelée plusieurs fois pour écrire des données JSON, ces données ne seront pas fusionnées en un seul objet JSON. Au lieu de cela, elles seront concaténées séquentiellement en tant que fragments de texte indépendants, ce qui pourrait entraîner un format JSON invalide. Si plusieurs éléments de données doivent être retournés, ils doivent être combinés en un seul objet avant la sérialisation, ou la logique doit être gérée manuellement.

Écrire du HTML

res.render(Text::Html("<html><body>hello</body></html>"));

Écriture d'erreurs HTTP

Utiliser render permet d'écrire des informations d'erreur détaillées dans la Response.

use salvo::http::errors::*;
res.render(StatusError::internal_server_error().brief("error when serialize object to json"))

Si des informations d'erreur personnalisées ne sont pas nécessaires, vous pouvez appeler directement set_http_code.
```
use salvo::http::StatusCode;
res.status_code(StatusCode::BAD_REQUEST);
```

Redirection vers une autre URL

En utilisant la méthode render, vous pouvez écrire une réponse de redirection dans la Response, naviguant vers une nouvelle URL. Lorsque vous appelez Redirect::found, cela définit le code d'état HTTP à 302 (Found), indiquant une redirection temporaire.
```
use salvo::prelude::*;

#[handler]
async fn redirect(res: &mut Response) {
    res.render(Redirect::found("https://salvo.rs/"));
}
```

ResBody

Le type de corps retourné par Response est ResBody, qui est une énumération. En cas d'erreur, il est défini sur ResBody::Error, contenant des informations d'erreur pour un traitement différé des erreurs. Notamment, StatusError n'implémente pas Writer ; cette conception vous permet de personnaliser son affichage dans le Catcher.

Aperçu des méthodes de la structure Response

Catégorie	Méthode	Description
Création	`new()` / `with_cookies()`	Créer une nouvelle réponse
Code d'état	`status_code()`	Définir le code d'état
En-têtes	`headers()/headers_mut()`	Obtenir les en-têtes
	`set_headers()/add_header()`	Définir/Ajouter des en-têtes
	`content_type()`	Obtenir le type de contenu
Version HTTP	`version()/version_mut()`	Obtenir/Modifier la version HTTP
Corps de la réponse	`body()/body_mut()`	Définir/Obtenir le corps de la réponse
	`replace_body()/take_body()`	Remplacer/Extraire le corps de la réponse
	`write_body()`	Écrire des données dans le corps de la réponse
	`stream()/channel()`	Réponse en flux / Créer un canal d'envoi
Gestion des cookies	`cookies()/cookie()`	Obtenir les cookies / Obtenir un cookie spécifique
	`add_cookie()/remove_cookie()`	Ajouter/Supprimer un cookie
Réponse de contenu	`render()`	Rendre le contenu
	`stuff()`	Définir le code d'état et rendre le contenu
	`send_file()`	Envoyer un fichier
Requête d'état	`is_stamped()`	Vérifier si la réponse est prête à être renvoyée

#Réponse

#Écriture de contenu

#Écriture d'erreurs HTTP

#Redirection vers une autre URL