Belajar Pengaturcaraan Rust · Pelajaran

Penghalaan Axum

Pengendali dan laluan

Pelajaran 1 daripada 413 langkah

Penghalaan Axum ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Apakah Axum?

Axum ialah rangka kerja web tak segerak yang ergonomik daripada pasukan Tokio. Ia dibina berasaskan tower dan hyper.

Pengendali ialah fungsi tak segerak biasa
Penghalaan dipacu jenis dan boleh digubah
Berjalan pada masa jalan Tokio

Pengendali ialah fungsi

Pengendali Axum ialah fungsi tak segerak yang mengembalikan sesuatu yang boleh ditukarkan kepada respons, seperti &str atau String.

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

Membina Router

Router memetakan laluan kepada pengendali. Gunakan route bersama penapis kaedah HTTP seperti get.

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

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

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

Memulakan pelayan

Ikat pendengar TCP dan sediakan penghala. Makro #[tokio::main] menyediakan masa jalan tak segerak.

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

Beberapa laluan

Rantaikan panggilan route untuk mendaftarkan beberapa titik akhir pada satu penghala.

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

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

Kaedah HTTP yang berbeza

Gabungkan pengendali kaedah pada satu laluan dengan get(...).post(...). Setiap kaedah dihalakan kepada pengendalinya sendiri.

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

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

Parameter laluan

Tangkap bahagian URL dengan segmen {name} dan bacanya melalui pengekstrak Path.

use axum::extract::Path;

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

Memodelkan penghalaan dalam Rust biasa

Pada asasnya, penghalaan memetakan laluan kepada respons. Model yang boleh dijalankan ini merangkum idea tersebut tanpa rangka kerja.

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

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

Menyusun penghala

Gubah app yang lebih besar dengan memasang subpenghala di bawah awalan menggunakan nest.

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

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

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

Pengendali sandaran

Tentukan perkara yang berlaku bagi laluan yang tidak sepadan menggunakan fallback. Sesuai untuk halaman 404 tersuai.

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

Mengembalikan kod status

Pengendali boleh mengembalikan tuple (StatusCode, body) untuk mengawal status respons dengan tepat.

use axum::http::StatusCode;

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

Semakan pantas

Uji pemahaman anda tentang penghalaan Axum.

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari asas penghalaan Axum:

Pengendali ialah fungsi tak segerak yang mengembalikan respons
Router::new().route(path, get(handler)) mendaftarkan titik akhir
Path menangkap segmen URL
nest, fallback dan tuple status membentuk app

Seterusnya: pengekstrak menghuraikan permintaan masuk.

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Penghalaan Axum” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Penghalaan Axum”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Penghalaan Axum”?

Pengendali dan laluan Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Penghalaan Axum” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Belajar Pengaturcaraan Rust