Middleware
Tower-lager
Middleware är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad är middleware?
Middleware kör kod före och efter en handler och omsluter förfrågnings-/svarscykeln. Använd det för loggning, autentisering, komprimering och tidsgränser.
- Axum bygger på ekosystemet kring
tower - Middleware läggs till som lager
Traitet Service
Tower definierar en Service: något som tar emot en förfrågan och asynkront producerar ett svar. Lager omsluter en service med en annan.
Lägga till ett lager
Koppla middleware med .layer(). Här lägger vi till spårning av förfrågningar från tower_http.
use axum::{Router, routing::get};
use tower_http::trace::TraceLayer;
fn app() -> Router {
Router::new()
.route("/", get(|| async { "ok" }))
.layer(TraceLayer::new_for_http())
}Ordning på lager
Lager omsluter nerifrån och upp: det sista lagret som läggs till är det yttersta. Förfrågningar går från yttre till inre lager och svar från inre till yttre lager.
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())
}Anpassad middleware med from_fn
middleware::from_fn omvandlar en asynkron funktion till middleware. Den tar emot förfrågningen och en Next som den anropar för att fortsätta resten av kedjan.
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
}Koppla in anpassad middleware
Omslut funktionen med from_fn och lägg till den som ett lager.
use axum::{Router, routing::get, middleware};
fn app() -> Router {
Router::new()
.route("/", get(|| async { "ok" }))
.layer(middleware::from_fn(log_mw))
}Avbryta förfrågningar i förtid
Middleware kan returnera tidigt utan att anropa next, vilket är användbart för autentisering. När ett svar returneras stoppas kedjan.
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)
}
}Modellera en middleware-kedja
En kedja består helt enkelt av funktioner som anropar nästa funktion. Det här körbara exemplet modellerar omslutningen före och efter.
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 per route
Tillämpa ett lager på en enskild route genom att anropa .layer() på metodroutern i stället för på hela appen.
use axum::{Router, routing::get, middleware};
fn app() -> Router {
Router::new().route(
"/admin",
get(|| async { "admin" }).layer(middleware::from_fn(auth)),
)
}Vanliga tower_http-lager
Crate:t tower_http levereras med färdiga middleware-komponenter:
TraceLayerför loggningCompressionLayerför gzipCorsLayerför CORSTimeoutLayerför att begränsa tiden för förfrågningar
use tower_http::cors::CorsLayer;
fn cors() -> CorsLayer {
CorsLayer::permissive()
}Stapla med ServiceBuilder
Gruppera flera lager på ett tydligt sätt med ServiceBuilder, som tillämpar dem uppifrån och ner för en förutsägbar ordning.
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())
}Snabbkontroll
Testa dina kunskaper om middleware.
Sammanfattning
Du har lärt dig middleware med tower-lager:
- Lägg till middleware via
.layer(); det senast tillagda lagret är ytterst from_fnbygger anpassad middleware medNext- Returnera tidigt för att avbryta kedjan, till exempel vid autentisering
tower_httperbjuder lager för spårning, komprimering, CORS och tidsgränser
Därmed är Axum-kursen klar.
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Middleware” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Middleware”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad lär jag mig i ”Middleware”?
Tower-lager Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Middleware”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.