Learn Rust Coding · Aula

Extratores

Analise requisições

Extratores é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O que é um extrator?

Um extrator é um parâmetro do handler que obtém uma parte da requisição para você. O Axum inspeciona os tipos dos parâmetros e os preenche.

Nenhuma análise manual da requisição
Orientado por tipos e combinável

Extrator Path

Path captura segmentos dinâmicos da URL. O tipo interno determina como o segmento é analisado.

use axum::extract::Path;

async fn user(Path(id): Path<u32>) -> String {
    format!("user {}", id)
}

Vários parâmetros de caminho

Capture vários segmentos extraindo uma tupla. A ordem corresponde ao padrão do caminho.

use axum::extract::Path;

async fn item(Path((cat, id)): Path<(String, u32)>) -> String {
    format!("{} / {}", cat, id)
}

Extrator Query

Query desserializa a cadeia de consulta da URL em uma estrutura usando serde. É excelente para filtros e paginação.

use axum::extract::Query;
use serde::Deserialize;

#[derive(Deserialize)]
struct Page { page: u32 }

async fn list(Query(p): Query<Page>) -> String {
    format!("page {}", p.page)
}

Extrator do corpo JSON

Json desserializa o corpo de uma requisição em uma estrutura. A estrutura deve derivar Deserialize.

use axum::Json;
use serde::Deserialize;

#[derive(Deserialize)]
struct NewUser { name: String }

async fn create(Json(u): Json<NewUser>) -> String {
    format!("created {}", u.name)
}

Extrator de cabeçalhos

Acesse cabeçalhos com o extrator HeaderMap ou com extratores de cabeçalhos tipados. É útil para tokens de autenticação.

use axum::http::HeaderMap;

async fn show(headers: HeaderMap) -> String {
    match headers.get("x-api-key") {
        Some(v) => format!("key: {:?}", v),
        None => "no key".to_string(),
    }
}

A ordem dos extratores é importante

Extratores que consomem o corpo, como Json, devem vir por último na lista de parâmetros, pois o corpo só pode ser lido uma vez.

use axum::{Json, extract::Path};
use serde::Deserialize;

#[derive(Deserialize)]
struct Body { value: i32 }

async fn h(Path(id): Path<u32>, Json(b): Json<Body>) -> String {
    format!("{} {}", id, b.value)
}

Representando a extração em Rust puro

A extração consiste simplesmente em analisar dados tipados de uma requisição. Aqui, desserializamos uma cadeia semelhante a uma consulta em números.

fn parse_query(q: &str) -> Option<u32> {
    q.strip_prefix("page=")?.parse().ok()
}

fn main() {
    println!("{:?}", parse_query("page=3"));
    println!("{:?}", parse_query("bad"));
}

Extração opcional

Envolva um extrator em Option para que ele não seja fatal. Um valor ausente ou inválido produz None em vez de uma resposta de erro.

use axum::extract::Query;
use serde::Deserialize;

#[derive(Deserialize)]
struct Filter { q: String }

async fn search(filter: Option<Query<Filter>>) -> String {
    match filter {
        Some(Query(f)) => f.q,
        None => "no filter".to_string(),
    }
}

Rejeições

Quando um extrator falha, ele retorna uma rejeição que se torna uma resposta de erro HTTP. Por exemplo, um JSON inválido produz automaticamente o status 422.

use axum::extract::rejection::JsonRejection;
use axum::Json;

async fn create(body: Result<Json<i32>, JsonRejection>) -> String {
    match body {
        Ok(Json(n)) => format!("ok {}", n),
        Err(_) => "bad body".to_string(),
    }
}

Combinando extratores

Um handler pode usar muitos extratores de uma só vez. O Axum preenche cada um com a parte correspondente da requisição.

use axum::{Json, extract::{Path, Query}};
use serde::Deserialize;

#[derive(Deserialize)]
struct Q { sort: String }
#[derive(Deserialize)]
struct B { name: String }

async fn h(Path(id): Path<u32>, Query(q): Query<Q>, Json(b): Json<B>) -> String {
    format!("{} {} {}", id, q.sort, b.name)
}

Verificação rápida

Teste sua compreensão sobre extratores.

Recapitulação

Você aprendeu a analisar requisições com extratores:

Path para segmentos da URL e Query para a cadeia de consulta
Json para o corpo (deve ser o último)
HeaderMap para cabeçalhos
Option e Result tratam falhas de forma adequada

A seguir: estado compartilhado e respostas JSON.

Perguntas Frequentes

A aula “Extratores” é grátis?

Sim — o texto completo de “Extratores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Extratores”?

Analise requisições Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Extratores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding