Learn Rust Coding · Lezione

Routing con Axum

Handler e route

Routing con Axum è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Che cos'è Axum?

Axum è un web framework asincrono ed ergonomico del team di Tokio. Si basa su tower e hyper.

Gli handler sono semplici funzioni asincrone
Il routing è basato sui tipi e componibile
Viene eseguito sul runtime Tokio

Un handler è una funzione

Un handler Axum è una funzione asincrona che restituisce qualcosa convertibile in una risposta, come &str o String.

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

Creare un Router

Router associa i percorsi agli handler. Usi route con un filtro per il metodo HTTP, come get.

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

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

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

Avviare il server

Assocî un listener TCP e avvii il router. La macro #[tokio::main] configura il runtime asincrono.

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

Più route

Concateni le chiamate a route per registrare diversi endpoint su un unico router.

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

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

Metodi HTTP diversi

Combini gli handler dei metodi su uno stesso percorso con get(...).post(...). Ogni metodo viene instradato al proprio handler.

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

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

Parametri del percorso

Catturi parti dell'URL con un segmento {name} e le legga tramite l'estrattore Path.

use axum::extract::Path;

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

Modellare il routing in Rust semplice

In sostanza, il routing associa un percorso a una risposta. Questo modello eseguibile esprime l'idea senza il 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"));
}

Annidare i router

Componi applicazioni più grandi montando un sub-router sotto un prefisso con 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 di fallback

Definisca cosa accade per le route non corrispondenti usando fallback. È ideale per pagine 404 personalizzate.

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

Restituire codici di stato

Un handler può restituire una tupla (StatusCode, body) per controllare con precisione lo stato della risposta.

use axum::http::StatusCode;

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

Verifica rapida

Verifichi la Sua comprensione del routing di Axum.

Riepilogo

Ha appreso le basi del routing di Axum:

Gli handler sono funzioni asincrone che restituiscono una risposta
Router::new().route(path, get(handler)) registra gli endpoint
Path cattura i segmenti dell'URL
nest, fallback e le tuple di stato definiscono la struttura dell'app

Prossimo argomento: gli estrattori analizzano le richieste in arrivo.

Domande Frequenti

La lezione «Routing con Axum» è gratuita?

Sì — il testo completo di «Routing con Axum» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Routing con Axum»?

Handler e route Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Routing con Axum»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding