Resposta

Em um Handler, a Response é passada como parâmetro:

A estrutura Response encapsula todos os componentes de uma resposta HTTP, fornecendo uma API abrangente para construir e manipular respostas HTTP.
Suporta um estilo fluente e encadeável (ex.: res.status_code(200).body("Hello")), facilitando a construção suave de respostas.
As funcionalidades principais incluem:
- Definir códigos de status e cabeçalhos
- Manipular o corpo da resposta (suportando strings, bytes, arquivos e dados em fluxo)
- Gerenciar cookies
- Múltiplos métodos de renderização de conteúdo
Esta estrutura emprega um padrão de referência mutável, retornando uma referência a si mesma via &mut self, permitindo que os handlers construam e personalizem convenientemente respostas HTTP para atender a diversos requisitos de serviços web.

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

Após o servidor receber uma requisição do cliente, qualquer Handler ou middleware correspondente pode escrever dados na Response. Em certos cenários, como quando um middleware deseja impedir a execução de middlewares e Handlers subsequentes, você pode usar FlowCtrl:

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

Escrevendo Conteúdo

Escrever dados em uma Response é direto:

Escrevendo dados de texto simples
```
res.render("Hello world!");
```

Escrevendo dados serializados em 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

Json<T> renderiza um documento JSON completo. No Salvo 0.94 e versoes posteriores, renderizar Json substitui os bytes do corpo ja armazenados em Response em vez de anexa-los. Para emitir varios registros JSON, serialize cada registro manualmente e anexe-o com write_body, por exemplo ao produzir NDJSON.

Escrevendo HTML

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

Escrevendo Erros HTTP

Usar render permite escrever informações detalhadas de erro na Response.

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

Se informações de erro personalizadas não forem necessárias, você pode chamar diretamente set_http_code.
```
use salvo::http::StatusCode;
res.status_code(StatusCode::BAD_REQUEST);
```

Redirecionando para Outra URL

Usando o método render, você pode escrever uma resposta de redirecionamento na Response, navegando para uma nova URL. Quando você chama Redirect::found, ele define o código de status HTTP para 302 (Found), indicando um redirecionamento temporário.
```
use salvo::prelude::*;

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

ResBody

O tipo de corpo retornado pela Response é ResBody, que é uma enumeração. Em caso de erro, é definido como ResBody::Error, contendo informações de erro para tratamento diferido. Notavelmente, StatusError não implementa Writer; este design permite que você personalize sua exibição no Catcher.

Visão Geral dos Métodos da Estrutura Response

Categoria	Método	Descrição
Criação	`new()` / `with_cookies()`	Criar uma nova resposta
Código de Status	`status_code()`	Definir o código de status
Cabeçalhos	`headers()/headers_mut()`	Obter cabeçalhos
	`set_headers()/add_header()`	Definir/Adicionar cabeçalhos
	`content_type()`	Obter tipo de conteúdo
Versão HTTP	`version()/version_mut()`	Obter/Modificar versão HTTP
Corpo da Resposta	`body()/body_mut()`	Definir/Obter o corpo da resposta
	`replace_body()/take_body()`	Substituir/Extrair o corpo da resposta
	`write_body()`	Escrever dados no corpo da resposta
	`stream()/channel()`	Resposta em fluxo / Criar um canal de envio
Manipulação de Cookies	`cookies()/cookie()`	Obter cookies / Obter um cookie específico
	`add_cookie()/remove_cookie()`	Adicionar/Remover um cookie
Resposta de Conteúdo	`render()`	Renderizar conteúdo
	`render_with_status()`	Definir código de status e renderizar conteúdo
	`send_file()`	Enviar um arquivo
Consulta de Status	`is_stamped()`	Verificar se a resposta está pronta para ser escrita de volta

#Resposta

#Escrevendo Conteúdo

#Escrevendo Erros HTTP

#Redirecionando para Outra URL

#ResBody