Response

In einem Handler wird die Response als Parameter übergeben:

Die Response-Struktur kapselt alle Komponenten einer HTTP-Antwort und bietet eine umfassende API zum Erstellen und Bearbeiten von HTTP-Antworten.
Sie unterstützt einen flüssigen, verkettbaren Stil (z. B. res.status_code(200).body("Hello")), der den reibungslosen Aufbau von Antworten erleichtert.
Zu den Kernfunktionen gehören:
- Setzen von Statuscodes und Headern
- Bearbeiten des Antwort-Bodys (Unterstützung von Strings, Bytes, Dateien und Streaming-Daten)
- Verwalten von Cookies
- Mehrere Methoden zur Inhaltsdarstellung
Diese Struktur verwendet ein veränderliches Referenzmuster, das über &mut self eine Referenz auf sich selbst zurückgibt, sodass Handler bequem HTTP-Antworten aufbauen und anpassen können, um verschiedenen Webdienst-Anforderungen gerecht zu werden.

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

Nachdem der Server eine Client-Anfrage empfangen hat, können alle passenden Handler oder Middleware Daten in die Response schreiben. In bestimmten Szenarien, z. B. wenn eine Middleware die Ausführung nachfolgender Middleware und Handler verhindern möchte, können Sie FlowCtrl verwenden:

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

Inhalte schreiben

Das Schreiben von Daten in eine Response ist unkompliziert:

Schreiben von Klartextdaten
```
res.render("Hello world!");
```

Schreiben von JSON-serialisierten Daten

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

Wenn die render-Methode mehrmals aufgerufen wird, um JSON-Daten zu schreiben, werden diese Daten nicht zu einem einzigen JSON-Objekt zusammengeführt. Stattdessen werden sie sequenziell als unabhängige Textfragmente verkettet, was möglicherweise zu einem ungültigen JSON-Format führt. Wenn mehrere Datenelemente zurückgegeben werden müssen, sollten sie vor der Serialisierung zu einem einzigen Objekt kombiniert oder die Logik manuell behandelt werden.

Schreiben von HTML

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

HTTP-Fehler schreiben

Mit render können detaillierte Fehlerinformationen in die Response geschrieben werden.

use salvo::http::errors::*;
res.render(StatusError::internal_server_error().brief("Fehler beim Serialisieren des Objekts zu JSON"))

Wenn keine benutzerdefinierten Fehlerinformationen benötigt werden, können Sie direkt set_http_code aufrufen.
```
use salvo::http::StatusCode;
res.status_code(StatusCode::BAD_REQUEST);
```

Weiterleitung zu einer anderen URL

Mit der render-Methode können Sie eine Weiterleitungsantwort in die Response schreiben, um zu einer neuen URL zu navigieren. Wenn Sie Redirect::found aufrufen, wird der HTTP-Statuscode auf 302 (Found) gesetzt, was eine temporäre Weiterleitung anzeigt.
```
use salvo::prelude::*;

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

ResBody

Der von Response zurückgegebene Body-Typ ist ResBody, eine Enumeration. Im Fehlerfall wird er auf ResBody::Error gesetzt, der Fehlerinformationen für die verzögerte Fehlerbehandlung enthält. Bemerkenswert ist, dass StatusError Writer nicht implementiert; dieses Design ermöglicht es Ihnen, seine Darstellung im Catcher anzupassen.

Übersicht über Response-Strukturmethoden

Kategorie	Methode	Beschreibung
Erstellung	`new()` / `with_cookies()`	Neue Antwort erstellen
Statuscode	`status_code()`	Statuscode setzen
Header	`headers()/headers_mut()`	Header abrufen
	`set_headers()/add_header()`	Header setzen/hinzufügen
	`content_type()`	Inhaltstyp abrufen
HTTP-Version	`version()/version_mut()`	HTTP-Version abrufen/ändern
Antwort-Body	`body()/body_mut()`	Antwort-Body setzen/abrufen
	`replace_body()/take_body()`	Antwort-Body ersetzen/extrahieren
	`write_body()`	Daten in den Antwort-Body schreiben
	`stream()/channel()`	Stream-Antwort / Sende-Kanal erstellen
Cookie-Verwaltung	`cookies()/cookie()`	Cookies abrufen / Bestimmtes Cookie abrufen
	`add_cookie()/remove_cookie()`	Cookie hinzufügen/entfernen
Inhaltsantwort	`render()`	Inhalt darstellen
	`stuff()`	Statuscode setzen und Inhalt darstellen
	`send_file()`	Datei senden
Statusabfrage	`is_stamped()`	Prüfen, ob die Antwort bereit zum Zurückschreiben ist

#Response

#Inhalte schreiben

#HTTP-Fehler schreiben

#Weiterleitung zu einer anderen URL