Learn Rust Coding · Lekcja

Ekstraktory

Analizowanie żądań

Ekstraktory to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Czym jest extractor?

Extractor to parametr handlera, który automatycznie wyodrębnia dla Ciebie fragment żądania. Axum analizuje typy parametrów i uzupełnia je.

Bez ręcznego parsowania żądań
Rozwiązanie oparte na typach, które można komponować

Extractor Path

Path przechwytuje dynamiczne segmenty adresu URL. Typ wewnątrz określa sposób parsowania segmentu.

use axum::extract::Path;

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

Wiele parametrów ścieżki

Przechwytuj kilka segmentów, wyodrębniając krotkę. Kolejność odpowiada wzorcowi ścieżki.

use axum::extract::Path;

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

Extractor Query

Query deserializuje ciąg zapytania URL do struktury za pomocą serde. Doskonale nadaje się do filtrów i paginacji.

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)
}

Extractor ciała JSON

Json deserializuje ciało żądania do struktury. Struktura musi wyprowadzać 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)
}

Extractor nagłówków

Uzyskuj dostęp do nagłówków za pomocą extractora HeaderMap lub extractorów typowanych nagłówków. Jest to przydatne w przypadku tokenów uwierzytelniających.

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(),
    }
}

Kolejność extractorów ma znaczenie

Extractory odczytujące ciało, takie jak Json, muszą znajdować się na końcu listy parametrów, ponieważ ciało można odczytać tylko raz.

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)
}

Modelowanie wyodrębniania w zwykłym Rust

Wyodrębnianie to po prostu parsowanie typowanych danych z żądania. Tutaj deserializujemy ciąg podobny do zapytania na liczby.

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

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

Opcjonalne wyodrębnianie

Owiń extractor w Option, aby jego niepowodzenie nie przerywało obsługi. Brakująca lub nieprawidłowa wartość daje None zamiast odpowiedzi z błędem.

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(),
    }
}

Odrzucenia

Gdy extractor zakończy się niepowodzeniem, zwraca odrzucenie, które staje się odpowiedzią HTTP z błędem. Na przykład nieprawidłowy JSON automatycznie daje kod 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(),
    }
}

Łączenie extractorów

Handler może jednocześnie używać wielu extractorów. Axum uzupełnia każdy z nich na podstawie odpowiedniej części żądania.

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)
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę o extractorach.

Podsumowanie

Nauczyłeś się parsować żądania za pomocą extractorów:

Path służy do segmentów adresu URL, a Query do ciągu zapytania
Json służy do ciała żądania i musi być ostatni
HeaderMap służy do nagłówków
Option i Result pozwalają łagodnie obsługiwać niepowodzenia

Dalej: współdzielony stan i odpowiedzi JSON.

Często zadawane pytania

Czy lekcja „Ekstraktory” jest bezpłatna?

Tak — pełny tekst „Ekstraktory” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Ekstraktory”?

Analizowanie żądań Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Ekstraktory”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding