Learn Rust Coding · Lektion

Axum-Routing

Handler und Routen

Axum-Routing ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was ist Axum?

Axum ist ein ergonomisches asynchrones Web-Framework des Tokio-Teams. Es baut auf tower und hyper auf.

Handler sind einfache asynchrone Funktionen
Routing ist typsicher und kombinierbar
Es läuft auf der Tokio-Runtime

Ein Handler ist eine Funktion

Ein Axum-Handler ist eine asynchrone Funktion, die etwas zurückgibt, das in eine Response umgewandelt werden kann, etwa ein &str oder ein String.

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

Einen Router erstellen

Der Router ordnet Pfade Handlern zu. Verwenden Sie route mit einem HTTP-Methodenfilter wie get.

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

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

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

Den Server starten

Binden Sie einen TCP-Listener und stellen Sie den Router bereit. Das Makro #[tokio::main] richtet die asynchrone Runtime ein.

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

Mehrere Routen

Verketten Sie Aufrufe von route, um mehrere Endpunkte in einem Router zu registrieren.

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

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

Verschiedene HTTP-Methoden

Kombinieren Sie Methoden-Handler für einen Pfad mit get(...).post(...). Jede Methode wird an ihren eigenen Handler weitergeleitet.

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

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

Pfadparameter

Erfassen Sie Teile der URL mit einem Segment der Form {name} und lesen Sie sie über den Extractor Path aus.

use axum::extract::Path;

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

Routing in einfachem Rust modellieren

Im Kern ordnet Routing einen Pfad einer Response zu. Dieses ausführbare Modell veranschaulicht die Idee ohne das Framework.

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

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

Router verschachteln

Erstellen Sie größere Anwendungen, indem Sie mit nest einen Unterrouter unter einem Präfix einhängen.

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

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

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

Fallback-Handler

Definieren Sie mit fallback, was bei nicht gefundenen Routen geschieht. Ideal für benutzerdefinierte 404-Seiten.

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

Status-Codes zurückgeben

Ein Handler kann ein Tupel aus (StatusCode, body) zurückgeben, um den Status der Response genau zu steuern.

use axum::http::StatusCode;

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

Kurzer Test

Testen Sie Ihr Verständnis des Axum-Routings.

Zusammenfassung

Sie haben die Grundlagen des Axum-Routings kennengelernt:

Handler sind asynchrone Funktionen, die eine Response zurückgeben
Router::new().route(path, get(handler)) registriert Endpunkte
Path erfasst URL-Segmente
nest, fallback und Status-Tupel strukturieren die Anwendung

Als Nächstes folgen Extractors zum Parsen eingehender Requests.

Häufig gestellte Fragen

Ist die Lektion „Axum-Routing“ kostenlos?

Ja — der vollständige Text von „Axum-Routing“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Axum-Routing“?

Handler und Routen Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Axum-Routing“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding