Response

In a Handler, the Response is passed as a parameter:

The Response struct encapsulates all components of an HTTP response, providing a comprehensive API for constructing and manipulating HTTP responses.
It supports a fluent, chainable style (e.g., res.status_code(200).body("Hello")), facilitating the smooth construction of responses.
Core functionalities include:
- Setting status codes and headers
- Manipulating the response body (supporting strings, bytes, files, and streaming data)
- Managing Cookies
- Multiple content rendering methods
This struct employs a mutable reference pattern, returning a reference to itself via &mut self, allowing handlers to conveniently build and customize HTTP responses to meet various web service requirements.

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

After the server receives a client request, any matched Handler or middleware can write data into the Response. In certain scenarios, such as when a middleware wishes to prevent the execution of subsequent middleware and Handlers, you can use FlowCtrl:

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

Writing Content

Writing data to a Response is straightforward:

Writing plain text data
```
res.render("Hello world!");
```

Writing JSON serialized data

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

Json<T> renders one complete JSON document. In Salvo 0.94 and later, rendering Json replaces any body bytes already buffered on the Response instead of appending to them. To emit multiple JSON records, serialize each record yourself and append it with write_body, for example when producing NDJSON.

Writing HTML

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

Writing HTTP Errors

Using render allows writing detailed error information to the Response.

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

If custom error information is not needed, you can directly call set_http_code.
```
use salvo::http::StatusCode;
res.status_code(StatusCode::BAD_REQUEST);
```

Redirecting to Another URL

Using the render method, you can write a redirect response to the Response, navigating to a new URL. When you call Redirect::found, it sets the HTTP status code to 302 (Found), indicating a temporary redirect.
```
use salvo::prelude::*;

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

ResBody

The Body type returned by Response is ResBody, which is an enum. In case of an error, it is set to ResBody::Error, containing error information for deferred error handling. Notably, StatusError does not implement Writer; this design allows you to customize its display in the Catcher.

Overview of Response Struct Methods

Category	Method	Description
Creation	`new()` / `with_cookies()`	Create a new response
Status Code	`status_code()`	Set the status code
Headers	`headers()/headers_mut()`	Get headers
	`set_headers()/add_header()`	Set/Add headers
	`content_type()`	Get content type
HTTP Version	`version()/version_mut()`	Get/Modify HTTP version
Response Body	`body()/body_mut()`	Set/Get the response body
	`replace_body()/take_body()`	Replace/Extract the response body
	`write_body()`	Write data to the response body
	`stream()/channel()`	Stream response / Create a sending channel
Cookie Handling	`cookies()/cookie()`	Get cookies / Get a specific cookie
	`add_cookie()/remove_cookie()`	Add/Remove a cookie
Content Response	`render()`	Render content
	`render_with_status()`	Set status code and render content
	`send_file()`	Send a file
Status Query	`is_stamped()`	Check if the response is ready to be written back

#Response

#Writing Content

#Writing HTTP Errors

#Redirecting to Another URL

#ResBody