PricingLoginStart free
Belajar Pengaturcaraan Rust · Pelajaran

Persediaan Projek

Susun struktur API

Pelajaran 1 daripada 413 langkah

Persediaan Projek 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.

Membina REST API dalam Rust

Dalam kursus ini, anda akan membina REST API kecil dalam Rust. Kami menggunakan rangka kerja web Axum, yang dibina berasaskan Tokio (runtime tak segerak) dan Tower (perisian tengah). Rangka kerja ini mudah digunakan, selamat dari segi jenis, dan digunakan secara meluas dalam persekitaran pengeluaran.

Pelajaran pertama ini menyediakan struktur projek supaya pelajaran seterusnya boleh menambah laluan, model, pangkalan data dan ujian.

Mencipta Projek

Mulakan dengan Cargo. Projek binari menyediakan titik masuk src/main.rs:

  • cargo new rest_api mencipta folder.
  • cd rest_api masuk ke dalam folder tersebut.
  • cargo run membina dan menjalankan projek.

Ini ialah perintah shell dan cargo, bukan petikan Rust yang boleh dijalankan.

// terminal
// cargo new rest_api
// cd rest_api
// cargo run

Menambah Kebergantungan

API Axum memerlukan beberapa peti dalam Cargo.toml:

  • axum untuk penghalaan dan pengendali.
  • tokio untuk runtime tak segerak.
  • serde untuk pensirilan JSON.
// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

Runtime Tak Segerak

Pelayan web mengendalikan banyak sambungan secara serentak, jadi Axum bersifat tak segerak. Atribut #[tokio::main] menukar main tak segerak menjadi titik masuk sebenar dengan memulakan runtime Tokio. Setiap pengendali boleh menggunakan .await untuk I/O tanpa sekatan.

// src/main.rs
use tokio;

#[tokio::main]
async fn main() {
    println!("runtime started");
}

Pelayan Minimum

Aplikasi Axum paling kecil membina Router, mengikat pendengar TCP dan menyediakan perkhidmatan. Satu laluan memetakan GET / kepada pengendali yang mengembalikan rentetan. Pengendali hanyalah fungsi tak segerak yang mengembalikan sesuatu yang melaksanakan IntoResponse.

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

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

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

Cara Penghalaan Berfungsi

Router memetakan laluan dan kaedah HTTP kepada pengendali. Rantaikan panggilan .route(path, method(handler)) untuk mendaftarkan titik akhir. Pembantu kaedah seperti get, post, put dan delete datang daripada axum::routing. Anda boleh menggabungkan kaedah pada laluan yang sama.

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

async fn list() -> &'static str { "list" }
async fn create() -> &'static str { "created" }

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

Susun Atur Modul yang Disyorkan

Apabila API berkembang, pecahkan kod kepada modul dan bukannya meletakkannya dalam satu main.rs yang besar:

  • main.rs — permulaan dan pendawaian pelayan.
  • routes.rs — takrif penghala.
  • handlers.rs — pengendali permintaan.
  • models.rs — struktur data.

Pemisahan ini memastikan setiap fail mempunyai fokus dan boleh diuji.

// src/main.rs
mod routes;
mod handlers;
mod models;

#[tokio::main]
async fn main() {
    let app = routes::build();
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Keadaan Aplikasi Dikongsi

Kebanyakan API memerlukan keadaan yang dikongsi, seperti kumpulan sambungan pangkalan data atau stor dalam memori. Axum menyimpannya dengan .with_state(state) pada penghala. Pengendali menerimanya melalui pengekstrak State. Keadaan tersebut mestilah Clone; bungkus data boleh ubah dalam Arc dan kunci.

use axum::{routing::get, Router, extract::State};
use std::sync::{Arc, Mutex};

type Db = Arc<Mutex<Vec<String>>>;

async fn count(State(db): State<Db>) -> String {
    let n = db.lock().unwrap().len();
    format!("{} items", n)
}

fn build(db: Db) -> Router {
    Router::new().route("/count", get(count)).with_state(db)
}

Mengembalikan JSON

Untuk menghantar JSON, bungkus nilai yang boleh disirilkan dalam axum::Json. Apabila Serialize diturunkan melalui serde pada struct anda, Axum menetapkan jenis kandungan dan badan secara automatik.

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Status {
    service: String,
    healthy: bool,
}

async fn health() -> Json<Status> {
    Json(Status { service: "api".into(), healthy: true })
}

Konfigurasi dan Port

Menetapkan port secara terus tidak mengapa untuk demonstrasi, tetapi perkhidmatan sebenar membaca konfigurasi daripada persekitaran. Gunakan std::env::var dengan nilai lalai. Ini membolehkan anda menukar alamat ikatan tanpa menyusun semula, serta berfungsi dengan baik bersama bekas.

use std::env;

async fn main_inner() {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);
    println!("binding to {}", addr);
    // bind and serve with addr ...
}

Menggabungkan Persediaan

Permulaan yang lengkap menyambungkan semuanya: bina penghala dengan laluan dan keadaan yang dikongsi, baca port, ikat pendengar dan sediakan perkhidmatan. Dengan rangka asas ini tersedia, pelajaran seterusnya akan menambah titik akhir, model dan penyimpanan berterusan sebenar.

use axum::{routing::get, Router};
use std::sync::{Arc, Mutex};

#[tokio::main]
async fn main() {
    let db = Arc::new(Mutex::new(Vec::<String>::new()));
    let app = Router::new()
        .route("/health", get(|| async { "ok" }))
        .with_state(db);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Semakan Pantas

Uji pemahaman anda tentang persediaan projek.

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah menyediakan projek REST API Rust:

  • Gunakan cargo new dan tambahkan axum, tokio serta serde.
  • #[tokio::main] menyediakan runtime tak segerak.
  • Router memetakan laluan dan kaedah kepada pengendali tak segerak.
  • Kongsi data dengan .with_state dan pengekstrak State.
  • Pecahkan kod kepada modul laluan, pengendali dan model; baca port daripada persekitaran.
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 percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Persediaan Projek” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Persediaan Projek”, 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 “Persediaan Projek”?

Susun struktur API 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 “Persediaan Projek” 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

  1. Persediaan Projek
  2. Titik Akhir dan Model
  3. Integrasi Pangkalan Data
  4. Menguji API
← Kembali ke Belajar Pengaturcaraan Rust