Learn Rust Coding · Lekcja

Routing w Axum

Handlery i trasy

Routing w Axum to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 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 Axum?

Axum to ergonomiczny, asynchroniczny framework webowy zespołu Tokio. Bazuje na tower i hyper.

Handlery są zwykłymi funkcjami asynchronicznymi
Routing opiera się na typach i można go komponować
Działa w środowisku uruchomieniowym Tokio

Handler jest funkcją

Handler Axum to asynchroniczna funkcja, która zwraca coś, co można przekształcić w odpowiedź, na przykład &str lub String.

async fn hello() -> &'static str {
    "Hello, world!"
}

Budowanie Router

Router mapuje ścieżki na handlery. Użyj route z filtrem metody HTTP, takim jak get.

use axum::{Router, routing::get};

async fn hello() -> &'static str { "Hello" }

fn app() -> Router {
    Router::new().route("/", get(hello))
}

Uruchamianie serwera

Powiąż nasłuchujący socket TCP i uruchom router. Makro #[tokio::main] konfiguruje środowisko uruchomieniowe dla kodu asynchronicznego.

use axum::{Router, routing::get};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(|| async { "Hi" }));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Wiele tras

Łącz wywołania route, aby zarejestrować kilka endpointów w jednym routerze.

use axum::{Router, routing::get};

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "home" }))
        .route("/about", get(|| async { "about" }))
}

Różne metody HTTP

Połącz handlery metod dla jednej ścieżki za pomocą get(...).post(...). Każda metoda przekazuje obsługę do własnego handlera.

use axum::{Router, routing::get};

fn app() -> Router {
    Router::new().route(
        "/items",
        get(|| async { "list" }).post(|| async { "create" }),
    )
}

Parametry ścieżki

Przechwytuj części adresu URL za pomocą segmentu {name} i odczytuj je przez extractor Path.

use axum::extract::Path;

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

Modelowanie routingu w zwykłym Rust

U podstaw routing mapuje ścieżkę na odpowiedź. Ten przykład, który można uruchomić, przedstawia tę ideę bez frameworka.

fn route(path: &str) -> &str {
    match path {
        "/" => "home",
        "/about" => "about page",
        _ => "404 not found",
    }
}

fn main() {
    println!("{}", route("/"));
    println!("{}", route("/about"));
    println!("{}", route("/missing"));
}

Zagnieżdżanie routerów

Twórz większe aplikacje, montując podruter pod określonym prefiksem za pomocą nest.

use axum::{Router, routing::get};

fn api() -> Router {
    Router::new().route("/users", get(|| async { "users" }))
}

fn app() -> Router {
    Router::new().nest("/api", api())
}

Handler awaryjny

Zdefiniuj zachowanie dla niedopasowanych tras za pomocą fallback. To idealne rozwiązanie dla niestandardowych stron 404.

use axum::{Router, http::StatusCode};

async fn not_found() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "nothing here")
}

fn app() -> Router {
    Router::new().fallback(not_found)
}

Zwracanie kodów statusu

Handler może zwracać krotkę (StatusCode, body), aby precyzyjnie określić status odpowiedzi.

use axum::http::StatusCode;

async fn create() -> (StatusCode, &'static str) {
    (StatusCode::CREATED, "created")
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę o routingu w Axum.

Podsumowanie

Poznałeś podstawy routingu w Axum:

Handlery są funkcjami asynchronicznymi zwracającymi odpowiedź
Router::new().route(path, get(handler)) rejestruje endpointy
Path przechwytuje segmenty adresu URL
nest, fallback i krotki statusu kształtują aplikację

Dalej: extractory parsują przychodzące żądania.

Często zadawane pytania

Czy lekcja „Routing w Axum” jest bezpłatna?

Tak — pełny tekst „Routing w Axum” 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 „Routing w Axum”?

Handlery i trasy Ć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 1 z 4.

Ile czasu zajmuje lekcja „Routing w Axum”?

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