Learn Rust Coding · Lektion

Middleware

Tower-Layer

Middleware ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 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 Middleware?

Middleware führt Code vor und nach einem Handler aus und umschließt den Request-/Response-Zyklus. Verwenden Sie es für Logging, Authentifizierung, Komprimierung und Timeouts.

Axum baut auf dem tower-Ökosystem auf
Middleware wird als Layer hinzugefügt

Das Service-Trait

Tower definiert einen Service: etwas, das einen Request entgegennimmt und asynchron eine Response erzeugt. Layer umschließen einen Service mit einem weiteren.

Einen Layer hinzufügen

Fügen Sie Middleware mit .layer() hinzu. Hier fügen wir Request-Tracing aus tower_http hinzu.

use axum::{Router, routing::get};
use tower_http::trace::TraceLayer;

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(TraceLayer::new_for_http())
}

Reihenfolge der Layer

Layer werden von unten nach oben geschachtelt: Der zuletzt hinzugefügte Layer ist der äußerste. Requests fließen von außen nach innen, Responses von innen nach außen.

use axum::{Router, routing::get};
use tower_http::{trace::TraceLayer, compression::CompressionLayer};

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(CompressionLayer::new())
        .layer(TraceLayer::new_for_http())
}

Benutzerdefinierte Middleware mit from_fn

middleware::from_fn wandelt eine asynchrone Funktion in Middleware um. Sie erhält den Request und ein Next, um den Rest der Kette aufzurufen.

use axum::{middleware::Next, response::Response, extract::Request};

async fn log_mw(req: Request, next: Next) -> Response {
    println!("{} {}", req.method(), req.uri());
    next.run(req).await
}

Benutzerdefinierte Middleware einbinden

Umschließen Sie Ihre Funktion mit from_fn und fügen Sie sie als Layer hinzu.

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

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(middleware::from_fn(log_mw))
}

Requests vorzeitig beenden

Middleware kann eine Response zurückgeben, ohne next aufzurufen, was beispielsweise für Authentifizierung nützlich ist. Das Zurückgeben einer Response beendet die Kette.

use axum::{middleware::Next, response::Response, extract::Request, http::StatusCode};

async fn auth(req: Request, next: Next) -> Result<Response, StatusCode> {
    if req.headers().contains_key("authorization") {
        Ok(next.run(req).await)
    } else {
        Err(StatusCode::UNAUTHORIZED)
    }
}

Eine Middleware-Kette modellieren

Eine Kette besteht einfach aus Funktionen, die jeweils die nächste Funktion aufrufen. Dieses ausführbare Beispiel modelliert das Umschließen vor und nach der Ausführung.

fn handler() -> String {
    "response".to_string()
}

fn logging<F: Fn() -> String>(next: F) -> String {
    println!("-> request in");
    let res = next();
    println!("<- response out");
    res
}

fn main() {
    let out = logging(handler);
    println!("body: {}", out);
}

Middleware pro Route

Wenden Sie einen Layer auf eine einzelne Route an, indem Sie .layer() am Methoden-Router statt an der gesamten Anwendung aufrufen.

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

fn app() -> Router {
    Router::new().route(
        "/admin",
        get(|| async { "admin" }).layer(middleware::from_fn(auth)),
    )
}

Häufig verwendete tower_http-Layer

Das tower_http-Crate stellt fertige Middleware bereit:

TraceLayer für Logging
CompressionLayer für gzip
CorsLayer für CORS
TimeoutLayer zur Begrenzung der Request-Dauer

use tower_http::cors::CorsLayer;

fn cors() -> CorsLayer {
    CorsLayer::permissive()
}

Layer mit ServiceBuilder stapeln

Gruppieren Sie mehrere Layer übersichtlich mit ServiceBuilder. Die Anwendung erfolgt von oben nach unten, wodurch die Reihenfolge vorhersehbar bleibt.

use tower::ServiceBuilder;
use tower_http::{trace::TraceLayer, compression::CompressionLayer};

fn stack() -> ServiceBuilder<impl Sized> {
    ServiceBuilder::new()
        .layer(TraceLayer::new_for_http())
        .layer(CompressionLayer::new())
}

Kurzer Test

Testen Sie Ihr Verständnis von Middleware.

Zusammenfassung

Sie haben Middleware mit tower-Layern kennengelernt:

Fügen Sie Middleware über .layer() hinzu; der zuletzt hinzugefügte Layer ist der äußerste
from_fn erstellt benutzerdefinierte Middleware mit Next
Geben Sie eine Response vorzeitig zurück, um die Kette zu beenden, beispielsweise für Authentifizierung
tower_http bietet Layer für Tracing, Komprimierung, CORS und Timeouts

Damit ist der Axum-Kurs abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Middleware“ kostenlos?

Ja — der vollständige Text von „Middleware“ 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 „Middleware“?

Tower-Layer 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 4 von 4.

Wie lange dauert die Lektion „Middleware“?

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