[Aprenda Rust juntos | Artigos avançados | biblioteca reqwest] Cliente HTTP escrito em Rust puro - reqwest

---

prefácio

reqwest é um cliente RUST HTTP simples, mas poderoso, para solicitações HTTP assíncronas do navegador. Suporta restrições xmlHttpRequest, JSONP, CORS e CommonJS.

Reqwest é fácil de usar e poderoso, incluindo modos assíncronos e de bloqueio, pode lidar com vários tipos de dados de solicitação, suporta proxy HTTP, criptografia TLS, armazenamento de cookies e outras funções, e também inclui suporte para WASM.

---

1. Instalação e referência

Adicione dependências ao Cargo.toml do projeto:

[dependencies]
reqwest = {
    
     version = "0.11", features = ["json"] }
tokio = {
    
     version = "1", features = ["full"] }

Em seguida, faça referência à biblioteca em seu programa

use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    
    
    let resp = reqwest::get("https://httpbin.org/ip")
        .await?
        .json::<HashMap<String, String>>()
        .await?;
    println!("{:#?}", resp);
    Ok(())
}

O código acima faz referência à biblioteca reqwest e cria uma solicitação cuja API é

https://httpbin.org/ip

Retorna o endereço IP do navegador que está solicitando no momento, que é seu endereço IP atual.

Execute este exemplo para ver o efeito

Você pode ver que as informações json retornadas pela API são obtidas, que contém meu endereço IP atual.

Dois, uso

1. Crie uma solicitação GET

Se for uma solicitação única, você pode usar o método get

let body = reqwest::get("https://www.rust-lang.org")
    .await?
    .text()
    .await?;

println!("body = {:?}", body);

Se você quiser fazer outras solicitações múltiplas, é melhor criar uma Clientpara reutilização.

2. Crie uma solicitação POST

Existem várias maneiras de definir o corpo da solicitação POST (corpo).

1. O método mais básico é usar o método body de RequestBuilder. Basta definir os dados originais do corpo. Aceita vários tipos, incluindo String e Vec<u8>. Se quiser customizar o tipo, você pode usar a estrutura reqwest::Body.

let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .body("the exact body that is sent")
    .send()
    .await?;

2. Formulário

É muito comum enviar dados de formulários no corpo da requisição. Isso pode ser feito usando qualquer tipo que possa ser serializado como dados de formulário. Seu tipo pode ser uma tupla, um HashMap ou um tipo personalizado, desde que você implemente o trait Serialize.

// 请求体是`foo=bar&baz=quux`
let params = [("foo", "bar"), ("baz", "quux")];
let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .form(&params)
    .send()
    .await?;

3. Formato JSON

Há também uma ferramenta de método json no RequestBuilder que funciona de maneira semelhante ao método de formulário. Ele pode aceitar qualquer valor que possa ser serializado para JSON. A funcionalidade JSON é muito necessária.

// 请求体 `{"lang":"rust","body":"json"}`
let mut map = HashMap::new();
map.insert("lang", "rust");
map.insert("body", "json");

let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .json(&map)
    .send()
    .await?;

4. Redirecionar

Por padrão, o cliente tratará automaticamente do redirecionamento e a cadeia de redirecionamento máxima é de 10 saltos. Para personalizar esse comportamento, "redirect::Policy" pode ser usado junto com "ClientBuilder".

Se uma URL for redirecionada para outra URL, se for redirecionada diretamente, é 1 salto; se houver uma transferência nela, são 2 saltos e, se houver N transferências no meio, é N+1 saltos .

5. Cookies

O armazenamento automático e o envio de cookies de sessão podem ser ativados usando o método cookie_store no ClientBuilder.

6. Procuração

O proxy do sistema é ativado por padrão

Se você estiver usando Socks, o proxy http e https pode usar as variáveis ​​de ambiente http_proxy e https_proxy para fornecer um proxy, você pode definir o proxy assim (somente ambiente Linux)

export https_proxy=socks5://127.0.0.1:1086

Se você estiver em um ambiente Windows, poderá usar uma estrutura reqwest::Proxy, por exemplo

let proxy = reqwest::Proxy::http("https://secure.example")?;

onde "https://secure.example"está a URL para obter o proxy. Esse proxy intercepta todas as solicitações e usa "https://secure.example"o proxy.

Várias regras de proxy podem ser configuradas para um cliente. O cliente verificará cada proxy na ordem em que foram adicionados. Isso pode significar que adicionar um proxy primeiro com uma regra de interceptação prioritária, como Proxy::all, impedirá que os proxies posteriores na lista funcionem, portanto, tenha cuidado.

Ativar proxy de meias

let proxy = reqwest::Proxy::http("socks5://192.168.1.1:9000")?;

7. Usando solicitações de bloqueio

Um cliente bloqueador bloqueará a execução do thread atual, em vez de retornar diretamente para continuar a execução. No entanto, as funções em reqwest::blocking não podem ser executadas dentro do tempo de execução assíncrono, caso contrário, ele travará ao tentar bloquear.

Adicione dependências ao Cargo.toml do projeto:

reqwest = {
    
     version = "0.11", features = ["blocking", "json"] }

Então escreva o código assim

use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    
    
    let resp = reqwest::blocking::get("https://httpbin.org/ip")?
        .json::<HashMap<String, String>>()?;
    println!("{:#?}", resp);
    Ok(())
}

1. Crie uma solicitação GET

A estrutura de resposta de bloqueio implementa a característica de leitura de Rust, portanto, muitas bibliotecas padrão e secundárias úteis têm métodos convenientes para obter uma resposta em qualquer lugar em que uma leitura seja aceitável.

let body = reqwest::blocking::get("https://www.rust-lang.org")?
    .text()?;

println!("body = {:?}", body);

Observe que se você deseja enviar várias solicitações, é recomendável criar um Cliente

2. Crie uma solicitação POST

A criação de uma requisição POST é basicamente a mesma que a sem bloqueio, mas se você quiser customizar o tipo de corpo da requisição, você precisa usar o método de construção, reqwest::blocking::Body::new()e esta é a única diferença da sem bloqueio. por favor, consulte o não-bloqueio.

let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .body("the exact body that is sent")
    .send()?;

---

Resumir

Nesta edição, aprendi o cliente HTTP escrito em Rust puro——reqwest e aprendi alguns métodos de solicitação da interface HTTP.

• Criar solicitações GET, POST
• usar proxy
• redirecionar
• Manipulando Cookies

Esta biblioteca é basicamente uma parte importante de todos os tipos de linguagens de programação. Ela pode interagir com o servidor da Web se puder iniciar uma solicitação e pode realizar mais funções se puder interagir. Com certeza se tornará uma parte muito importante do seguinte -para cima .