Learn Rust Coding · Pelajaran

Middleware

Layer Tower

Middleware adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa itu middleware?

Perantara menjalankan kode sebelum dan sesudah penangan, dengan membungkus siklus permintaan/respons. Gunakan ini untuk pencatatan, autentikasi, kompresi, dan batas waktu.

Axum dibangun di atas ekosistem tower
Perantara ditambahkan sebagai lapisan

Trait Service

Tower mendefinisikan Service: sesuatu yang menerima permintaan dan menghasilkan respons secara asinkron. Lapisan membungkus satu layanan menjadi layanan lainnya.

Menambahkan lapisan

Pasang perantara dengan .layer(). Di sini, kita menambahkan pelacakan permintaan dari 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())
}

Urutan lapisan

Lapisan membungkus dari bawah ke atas: lapisan terakhir yang ditambahkan menjadi lapisan terluar. Permintaan mengalir dari luar ke dalam, sedangkan respons mengalir dari dalam ke luar.

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

Perantara khusus dengan from_fn

middleware::from_fn mengubah fungsi asinkron menjadi perantara. Fungsi ini menerima permintaan dan Next untuk memanggil bagian rantai lainnya.

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
}

Menghubungkan perantara khusus

Bungkus fungsi Anda dengan from_fn dan tambahkan sebagai lapisan.

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

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

Menghentikan permintaan lebih awal

Perantara dapat mengembalikan hasil lebih awal tanpa memanggil next, yang berguna untuk autentikasi. Mengembalikan respons akan menghentikan rantai.

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

Memodelkan rantai perantara

Rantai hanyalah fungsi-fungsi yang memanggil fungsi berikutnya. Contoh yang dapat dijalankan ini memodelkan pembungkusan sebelum/sesudah.

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

Perantara per rute

Terapkan lapisan ke satu rute dengan memanggil .layer() pada perute metode, bukan pada seluruh aplikasi.

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

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

Lapisan tower_http yang umum

Crate tower_http menyediakan perantara siap pakai:

TraceLayer untuk pencatatan
CompressionLayer untuk gzip
CorsLayer untuk CORS
TimeoutLayer untuk membatasi waktu permintaan

use tower_http::cors::CorsLayer;

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

Menumpuk dengan ServiceBuilder

Kelompokkan beberapa lapisan dengan rapi menggunakan ServiceBuilder, yang menerapkannya dari atas ke bawah agar urutannya dapat diprediksi.

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

Pemeriksaan Singkat

Uji pemahaman Anda tentang perantara.

Rangkuman

Anda telah mempelajari perantara dengan lapisan tower:

Tambahkan perantara melalui .layer(); lapisan terakhir yang ditambahkan menjadi lapisan terluar
from_fn membuat perantara khusus menggunakan Next
Kembalikan hasil lebih awal untuk menghentikan rantai, misalnya untuk autentikasi
tower_http menyediakan lapisan pelacakan, kompresi, CORS, dan batas waktu

Pelajaran Axum selesai.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Middleware” gratis?

Ya — teks lengkap “Middleware” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Middleware”?

Layer Tower Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Middleware” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding