I. Pendahuluan
Pengembangan aplikasi web semakin menjadi fokus utama dalam dunia pemrograman modern. Dalam ekosistem ini, Rust, dengan keamanan dan kinerja tinggi, telah muncul sebagai bahasa yang menarik bagi para pengembang yang mencari alternatif baru. Rocket Framework adalah salah satu framework web yang memungkinkan pengembang untuk membuat aplikasi web dengan cepat dan aman menggunakan Rust.
A. Pengenalan tentang Rust sebagai Bahasa Pemrograman Web
Rust adalah bahasa pemrograman yang inovatif yang telah mendapatkan popularitas karena fokusnya pada keamanan, kejelasan, dan kinerja. Meskipun Rust lebih dikenal dalam pengembangan perangkat lunak sistem tingkat rendah, seperti sistem operasi dan mesin virtual, namun Rust juga menawarkan kemampuan yang kuat dalam pengembangan aplikasi web.
B. Pengantar tentang Rocket Framework
Rocket adalah salah satu framework web terkemuka untuk Rust. Dirancang dengan konsep yang terinspirasi dari pemrograman fungsional dan berorientasi pada makro, Rocket memungkinkan pengembang untuk membuat API web dengan cepat dan aman. Dengan fitur-fitur seperti routing statis, middleware, dan type-driven development, Rocket membuat pengembangan aplikasi web menjadi lebih menyenangkan dan efisien.
C. Tujuan dan Ruang Lingkup Tutorial
Dalam tutorial ini, kita akan menjelajahi penggunaan Rust untuk pengembangan aplikasi web melalui pembangunan sebuah API Restful menggunakan Rocket Framework. Langkah-langkah yang akan kita lakukan meliputi instalasi dan persiapan lingkungan pengembangan, pembuatan endpoint-endpoint API, pengelolaan state aplikasi, pengujian, penggunaan database, penyebaran aplikasi, dan eksplorasi fitur-fitur lanjutan dari Rocket Framework.
Dengan mengikuti tutorial ini, pembaca akan mendapatkan pemahaman yang kuat tentang bagaimana menggunakan Rust dan Rocket Framework untuk membangun aplikasi web yang efisien, aman, dan tangguh. Sekarang, mari kita mulai dengan persiapan lingkungan pengembangan.
II. Persiapan Lingkungan Pengembangan
Sebelum kita mulai membangun aplikasi web dengan Rust menggunakan Rocket Framework, langkah pertama yang harus dilakukan adalah menyiapkan lingkungan pengembangan. Dalam bagian ini, kita akan membahas langkah-langkah untuk mengatur lingkungan pengembangan Rust dan mengintegrasikan Rocket Framework ke dalam proyek.
A. Instalasi Rust dan Cargo
Rust dan Cargo merupakan bagian yang tidak terpisahkan dalam pengembangan aplikasi dengan Rust. Rust adalah bahasa pemrograman itu sendiri, sedangkan Cargo adalah manajer dependensi dan alat build yang kuat untuk Rust.
- Instalasi Rust: Unduh dan instalasi Rust dari situs resmi rust-lang.org.
- Verifikasi Instalasi: Pastikan Rust sudah terinstal dengan menjalankan perintah
rustc --versiondancargo --versiondi terminal.
B. Membuat Proyek Baru dengan Cargo
Setelah Rust dan Cargo terinstal, kita dapat membuat proyek baru menggunakan Cargo. Cargo akan membuat struktur proyek standar dan menangani dependensi proyek secara otomatis.
- Membuat Proyek Baru: Buka terminal dan jalankan perintah
cargo new nama_proyek --binuntuk membuat proyek baru. Gantinama_proyekdengan nama proyek yang diinginkan. - Struktur Proyek: Periksa struktur proyek yang telah dibuat oleh Cargo. Struktur ini biasanya terdiri dari direktori
src/untuk kode sumber danCargo.tomluntuk file konfigurasi proyek.
C. Menambahkan Dependensi Rocket ke dalam Proyek
Setelah proyek dibuat, langkah selanjutnya adalah menambahkan Rocket Framework sebagai dependensi ke dalam proyek. Rocket dapat ditambahkan ke dalam proyek dengan menambahkannya ke dalam file Cargo.toml.
- Menambahkan Dependensi Rocket: Buka file
Cargo.tomldan tambahkan barisrocket = "0.5.0-rc.1"di bawah bagian[dependencies]. - Pembaruan Dependensi: Jalankan perintah
cargo updatedi terminal untuk memastikan dependensi Rocket yang sudah ditambahkan ke dalam proyek terunduh dengan benar.
Dengan langkah-langkah di atas, lingkungan pengembangan Rust telah siap untuk memulai pembangunan aplikasi web menggunakan Rocket Framework. Selanjutnya, kita akan mulai dengan membuat endpoint sederhana dalam aplikasi web kita.
III. Membuat Endpoint Sederhana
Setelah lingkungan pengembangan sudah terpasang dengan baik, langkah selanjutnya adalah memulai pembangunan aplikasi web dengan membuat endpoint sederhana menggunakan Rocket Framework. Dalam bagian ini, kita akan mempelajari cara mendefinisikan endpoint HTTP sederhana untuk mengembalikan respons statis.
A. Pendefinisian Endpoint dengan Rocket
Rocket memungkinkan pengembang untuk mendefinisikan endpoint HTTP dengan mudah menggunakan decorator. Decorator digunakan untuk menandai fungsi handler yang akan dipanggil ketika endpoint tertentu diakses.
- Import Rocket Macros: Pastikan untuk mengimpor makro-makro Rocket di bagian atas file
src/main.rs:
#[macro_use]
extern crate rocket;Code language: CSS (css)- Mendefinisikan Endpoint: Buat fungsi handler baru dengan menambahkan decorator
#[get("/")]di atasnya. Ini akan menandai fungsi tersebut sebagai penanganan untuk permintaan HTTP GET pada root path (“/”):
#[get("/")]
fn index() -> &'static str {
"Halo, dunia!"
}Code language: PHP (php)B. Menggunakan Decorator untuk Menentukan Path dan Method HTTP
Rocket menggunakan decorator untuk menentukan path dan method HTTP yang akan ditangani oleh sebuah fungsi handler. Berikut beberapa decorator umum yang sering digunakan:
#[get("/path")]: Menandai fungsi sebagai penanganan untuk permintaan HTTP GET pada path tertentu.#[post("/path")]: Menandai fungsi sebagai penanganan untuk permintaan HTTP POST pada path tertentu.#[put("/path")]: Menandai fungsi sebagai penanganan untuk permintaan HTTP PUT pada path tertentu.#[delete("/path")]: Menandai fungsi sebagai penanganan untuk permintaan HTTP DELETE pada path tertentu.
C. Mengembalikan Respons Sederhana
Fungsi handler dapat mengembalikan berbagai jenis respons, termasuk teks, JSON, HTML, dan lain-lain. Untuk contoh sederhana ini, kita akan mengembalikan sebuah string statis.
- Mengembalikan Respons String: Dalam fungsi handler
index(), kita mengembalikan string statis “Halo, dunia!”:
fn index() -> &'static str {
"Halo, dunia!"
}Dengan langkah-langkah di atas, kita telah berhasil mendefinisikan sebuah endpoint sederhana menggunakan Rocket Framework. Sekarang, kita dapat menjalankan aplikasi dan mengakses endpoint tersebut menggunakan browser atau perangkat lunak lainnya.
IV. Penggunaan Struktur Data
Dalam pengembangan aplikasi web, seringkali kita perlu berurusan dengan data yang kompleks, seperti entitas pengguna, artikel, atau pesanan. Rust memungkinkan kita untuk mendefinisikan struktur data untuk merepresentasikan entitas-entitas ini dengan mudah. Dalam bagian ini, kita akan mempelajari cara menggunakan struktur data untuk model dalam API kita.
A. Mendefinisikan Struktur Data
Pertama-tama, kita perlu mendefinisikan struktur data untuk merepresentasikan model dalam API kita. Contohnya, jika kita ingin membuat API untuk mengelola pengguna, kita dapat membuat struktur data User.
- Contoh Struktur Data
User:
#[derive(Debug)]
struct User {
id: i32,
username: String,
email: String,
}Code language: CSS (css)B. Menggunakan Serde untuk Serialisasi dan Deserialisasi Data
Untuk berinteraksi dengan data dalam format JSON, kita perlu dapat mengonversi struktur data Rust ke dalam format JSON (serialisasi) dan sebaliknya (deserialisasi). Library serde sangat berguna untuk tugas ini.
- Menambahkan Serde ke dalam Dependensi: Tambahkan serde ke dalam dependensi Cargo.toml:
[dependencies]
rocket = "0.5.0-rc.1"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"Code language: JavaScript (javascript)- Menerapkan Trait Serialize dan Deserialize: Implementasikan trait Serialize dan Deserialize untuk struktur data kita agar dapat digunakan oleh serde.
#[derive(Debug, Serialize, Deserialize)]
struct User {
id: i32,
username: String,
email: String,
}Code language: CSS (css)C. Menggunakan Parameter Path dan Query untuk Mengakses Data
Dalam endpoint, kita dapat menggunakan parameter path atau query untuk mengakses data yang dikirim oleh klien. Kita dapat menggunakan struktur data Rust sebagai tipe parameter dalam fungsi handler untuk menerima data dari klien.
- Contoh Penggunaan Parameter Path:
#[get("/user/<id>")]
fn get_user(id: i32) -> String {
format!("Mendapatkan data untuk pengguna dengan ID {}", id)
}Code language: PHP (php)- Contoh Penggunaan Parameter Query:
#[get("/users?<page>&<limit>")]
fn get_users(page: Option<i32>, limit: Option<i32>) -> String {
format!("Mendapatkan daftar pengguna dengan halaman {} dan batas {}", page.unwrap_or(1), limit.unwrap_or(10))
}Code language: HTML, XML (xml)Dengan menggunakan struktur data untuk merepresentasikan model dalam API kita, serta menggunakan serde untuk serialisasi dan deserialisasi data, kita dapat dengan mudah berinteraksi dengan data dalam format JSON. Selanjutnya, kita akan melihat bagaimana kita dapat mengelola state aplikasi dalam Rocket Framework.
V. Mengelola State Aplikasi
Dalam pengembangan aplikasi web, seringkali kita perlu menyimpan data yang dibagikan di antara beberapa endpoint atau mengakses sumber daya eksternal seperti database. Dalam Rocket Framework, pengelolaan state aplikasi memungkinkan kita untuk melakukan hal ini dengan mudah. Dalam bagian ini, kita akan mempelajari cara mendefinisikan dan menggunakan state aplikasi dalam Rocket.
A. Pengenalan tentang State dalam Rocket
State dalam Rocket adalah cara untuk menyimpan data yang bersifat global dan dapat diakses dari seluruh aplikasi. Ini berguna ketika kita perlu menyimpan status atau sumber daya yang dibagikan di antara beberapa endpoint.
- Pendefinisian State: State dalam Rocket didefinisikan sebagai struktur data Rust yang diawali dengan
State<T>, di manaTadalah tipe data dari state tersebut.
B. Mendefinisikan dan Menggunakan State Aplikasi
Setelah state didefinisikan, kita dapat menggunakannya dalam fungsi handler atau di tempat lain dalam aplikasi.
- Menggunakan State dalam Fungsi Handler: State dapat digunakan sebagai parameter dalam fungsi handler untuk mengakses data yang disimpan dalam state aplikasi.
#[get("/")]
fn index(state: &State<MyState>) -> String {
format!("Nilai state: {}", state.inner().value)
}Code language: PHP (php)- Menyimpan Data dalam State: Data dapat disimpan dalam state aplikasi menggunakan fungsi
managedi dalam blokRocket::build().
#[rocket::main]
async fn main() {
rocket::build()
.manage(MyState::new())
.mount("/", routes![index])
.launch()
.await
.expect("Failed to launch Rocket application");
}Code language: CSS (css)C. Contoh Penggunaan State untuk Menyimpan Data Bersama
Untuk memahami penggunaan state aplikasi dalam praktek, mari kita lihat contoh sederhana penggunaannya untuk menyimpan nilai status aplikasi yang dibagikan di antara beberapa endpoint.
- Definisi Struktur Data State:
use rocket::State;
struct MyState {
value: i32,
}
impl MyState {
fn new() -> Self {
MyState { value: 42 }
}
}Code language: PHP (php)- Menyimpan dan Mengakses Data dalam State:
#[get("/")]
fn index(state: &State<MyState>) -> String {
format!("Nilai state: {}", state.inner().value)
}Code language: PHP (php)Dengan penggunaan state aplikasi, kita dapat dengan mudah menyimpan dan mengakses data yang dibagikan di antara beberapa endpoint dalam aplikasi kita. Hal ini memungkinkan kita untuk membuat aplikasi yang lebih kompleks dengan kemampuan interaksi yang lebih kuat antar komponen-komponennya. Selanjutnya, kita akan melihat bagaimana kita dapat menggunakan middleware untuk menambahkan fungsi sebelum atau sesudah penanganan permintaan.
VI. Middleware dan Error Handling
Middleware adalah fungsi yang dijalankan sebelum atau sesudah penanganan permintaan HTTP. Middleware sering digunakan untuk melakukan tugas-tugas seperti otentikasi, logging, atau kompresi data. Selain itu, kita juga perlu menangani kesalahan yang mungkin terjadi dalam aplikasi web kita. Dalam bagian ini, kita akan mempelajari cara menggunakan middleware dan menangani kesalahan dalam Rocket Framework.
A. Penggunaan Middleware untuk Menambahkan Fungsi Sebelum atau Sesudah Penanganan Permintaan
Middleware adalah cara yang baik untuk menambahkan fungsi-fungsi tambahan sebelum atau sesudah penanganan permintaan HTTP. Rocket menyediakan cara yang mudah untuk menambahkan middleware ke dalam aplikasi.
- Pendefinisian Middleware: Middleware didefinisikan sebagai fungsi yang mengambil
RequestdanDatadan mengembalikanOutcome.
#[rocket::middleware]
async fn logger(request: &Request<'_>, data: &Data<'_>) -> Outcome<'_> {
println!("{} {}", request.method(), request.uri());
Outcome::Forward(())
}Code language: HTML, XML (xml)- Mendaftarkan Middleware: Middleware didaftarkan menggunakan fungsi
registerdi dalam blokRocket::build().
#[rocket::main]
async fn main() {
rocket::build()
.register("/", catchers![not_found])
.attach(logger::logger())
.mount("/", routes![index])
.launch()
.await
.expect("Failed to launch Rocket application");
}Code language: CSS (css)B. Menangani Kesalahan dengan Rocket
Ketika kesalahan terjadi dalam aplikasi web kita, penting untuk menangani mereka dengan cara yang baik agar respons yang dihasilkan informatif bagi pengguna. Rocket memungkinkan kita untuk menangani kesalahan dengan baik melalui penggunaan catcher.
- Pendefinisian Catcher: Catcher didefinisikan sebagai fungsi yang mengambil
&Requestdan mengembalikanOption<Response>.
#[catch(404)]
fn not_found(request: &Request<'_>) -> String {
format!("Halaman {} tidak ditemukan", request.uri())
}Code language: HTML, XML (xml)- Mendaftarkan Catcher: Catcher didaftarkan menggunakan fungsi
registerdi dalam blokRocket::build().
#[rocket::main]
async fn main() {
rocket::build()
.register("/", catchers![not_found])
.attach(logger::logger())
.mount("/", routes![index])
.launch()
.await
.expect("Failed to launch Rocket application");
}Code language: CSS (css)C. Menggunakan Custom Error Types untuk Meningkatkan Kejelasan Pesan Kesalahan
Seringkali, kita ingin menggunakan jenis kesalahan kustom untuk meningkatkan kejelasan pesan kesalahan yang dikirimkan kepada klien. Rocket memungkinkan kita untuk melakukan hal ini dengan mudah.
- Pendefinisian Jenis Kesalahan Kustom:
#[derive(Debug)]
enum CustomError {
NotFound,
InternalServerError,
}Code language: PHP (php)- Implementasi Trait From untuk Konversi ke Response: Implementasikan trait
Fromuntuk mengonversi jenis kesalahan kustom menjadi respons HTTP yang sesuai.
impl<'r> From<CustomError> for Response<'r> {
fn from(error: CustomError) -> Self {
match error {
CustomError::NotFound => Response::builder()
.status(Status::NotFound)
.body(format!("Halaman tidak ditemukan"))
.unwrap(),
CustomError::InternalServerError => Response::builder()
.status(Status::InternalServerError)
.body(format!("Terjadi kesalahan internal"))
.unwrap(),
}
}
}Code language: PHP (php)Dengan menggunakan middleware untuk menambahkan fungsi sebelum atau sesudah penanganan permintaan, serta menangani kesalahan dengan baik melalui catcher, kita dapat memastikan bahwa aplikasi web kita responsif dan ramah pengguna. Selanjutnya, kita akan melihat bagaimana kita dapat menggunakan database dalam aplikasi web kita.
VII. Pengujian API
Pengujian merupakan bagian penting dari pengembangan perangkat lunak untuk memastikan bahwa aplikasi berfungsi sesuai dengan yang diharapkan dan memberikan hasil yang konsisten. Dalam konteks pengembangan aplikasi web dengan Rocket Framework, pengujian API sangat penting untuk memvalidasi perilaku endpoint-endpoint yang telah kita definisikan. Dalam bagian ini, kita akan membahas berbagai pendekatan untuk melakukan pengujian API dengan Rust dan Rocket.
A. Pendekatan Pengujian untuk API
Pada dasarnya, pengujian API dapat dilakukan dengan menggunakan dua pendekatan utama: pengujian unit dan pengujian integrasi.
- Pengujian Unit: Pengujian unit bertujuan untuk menguji setiap komponen aplikasi secara terpisah, termasuk fungsi handler dan logika bisnis yang terkait. Dalam konteks Rocket, ini berarti menguji setiap fungsi handler secara terisolasi.
- Pengujian Integrasi: Pengujian integrasi lebih fokus pada menguji bagaimana komponen-komponen aplikasi berinteraksi satu sama lain. Dalam konteks Rocket, ini berarti menguji bagaimana endpoint-endpoint berkomunikasi dengan satu sama lain dan dengan sumber daya eksternal seperti database.
B. Menerapkan Unit Test untuk Endpoint
Dalam Rocket, pengujian unit untuk endpoint-endpoint dapat dilakukan dengan menguji fungsi handler menggunakan kerangka pengujian Rust bawaan, seperti #[test].
- Contoh Pengujian Unit untuk Fungsi Handler:
#[cfg(test)]
mod tests {
use super::*;
use rocket::local::blocking::Client;
#[test]
fn test_index() {
let rocket = rocket::build().mount("/", routes![index]);
let client = Client::tracked(rocket).expect("failed to create client");
let response = client.get("/").dispatch();
assert_eq!(response.status(), Status::Ok);
assert_eq!(response.into_string(), Some("Halo, dunia!".into()));
}
}Code language: PHP (php)C. Menerapkan Pengujian Integrasi dengan Rocket Testing API
Rocket menyediakan API pengujian khusus yang memungkinkan kita untuk melakukan pengujian integrasi pada endpoint-endpoint API kita dengan mudah.
- Contoh Pengujian Integrasi dengan Rocket Testing API:
#[cfg(test)]
mod tests {
use super::*;
use rocket::local::blocking::Client;
#[test]
fn test_index() {
let rocket = rocket::build().mount("/", routes![index]);
let client = Client::tracked(rocket).expect("failed to create client");
let response = client.get("/").dispatch();
assert_eq!(response.status(), Status::Ok);
assert_eq!(response.into_string(), Some("Halo, dunia!".into()));
}
}Code language: PHP (php)D. Pengujian Integrasi dengan Database
Saat mengembangkan aplikasi web yang berinteraksi dengan database, penting untuk menguji perilaku aplikasi saat berkomunikasi dengan database. Rocket memudahkan pengujian integrasi dengan database dengan menyediakan dukungan untuk pengujian pada modus pengembangan.
- Pengujian Integrasi dengan Database pada Modus Pengembangan:
#[cfg(test)]
mod tests {
use super::*;
use rocket::local::blocking::Client;
use rocket::local::LocalResponse;
#[rocket::async_test]
async fn test_create_user() {
let rocket = rocket::build().attach(Database::fairing());
let client = Client::tracked(rocket).expect("failed to create client");
let request_body = serde_json::json!({
"username": "user1",
"email": "[email protected]"
});
let response = client
.post("/user")
.header(ContentType::JSON)
.body(request_body.to_string())
.dispatch()
.await;
assert_eq!(response.status(), Status::Created);
}
}Code language: PHP (php)Dengan menerapkan pengujian unit dan integrasi, kita dapat memastikan bahwa aplikasi web yang kita kembangkan berfungsi sesuai yang diharapkan dan memberikan hasil yang konsisten. Hal ini membantu meningkatkan kualitas dan keandalan aplikasi serta mempercepat siklus pengembangan secara keseluruhan. Selanjutnya, kita akan melihat bagaimana kita dapat menggunakan database dalam aplikasi web kita.
VIII. Penggunaan Database
Dalam pengembangan aplikasi web modern, penggunaan database sangatlah umum. Dengan menggunakan database, kita dapat menyimpan, mengambil, dan memanipulasi data dengan mudah. Dalam konteks pengembangan aplikasi web dengan Rust dan Rocket Framework, kita dapat mengintegrasikan berbagai jenis database dengan mudah menggunakan berbagai library yang tersedia. Dalam bagian ini, kita akan membahas cara menggunakan database dalam aplikasi web kita dengan Rocket Framework.
A. Pengenalan tentang Koneksi Database dengan Rust
Sebelum kita dapat menggunakan database dalam aplikasi web kita, kita perlu terlebih dahulu melakukan koneksi ke database tersebut. Rust menyediakan berbagai library dan driver database yang dapat digunakan untuk melakukan koneksi ke berbagai jenis database.
- Pilihan Database: Pilih jenis database yang akan digunakan dalam aplikasi web kita. Contoh database yang umum digunakan termasuk PostgreSQL, MySQL, SQLite, dan MongoDB.
- Instalasi Dependensi: Instalasi dependensi Rust yang sesuai untuk menghubungkan aplikasi dengan database yang dipilih. Pastikan untuk memilih driver yang cocok dengan jenis database yang akan digunakan.
B. Menggunakan ORM atau Query Builder untuk Berinteraksi dengan Database
Setelah kita terhubung ke database, langkah selanjutnya adalah berinteraksi dengan data dalam database tersebut. Dalam Rust, terdapat beberapa pilihan pendekatan yang dapat digunakan untuk berinteraksi dengan database, antara lain menggunakan ORM (Object-Relational Mapping) atau query builder.
- ORM (Object-Relational Mapping): ORM memungkinkan kita untuk berinteraksi dengan database menggunakan objek dan model data yang terdefinisi dalam kode Rust kita. Beberapa contoh ORM yang populer dalam ekosistem Rust termasuk Diesel, sqlx, dan rusqlite.
- Query Builder: Query builder adalah alat yang memungkinkan kita untuk membangun dan menjalankan kueri SQL menggunakan kode Rust. Dengan menggunakan query builder, kita dapat menulis kueri SQL dalam kode Rust kita dengan cara yang aman dan terstruktur.
C. Integrasi Database ke dalam Rocket Framework
Setelah kita memiliki koneksi ke database dan memilih pendekatan untuk berinteraksi dengan database, langkah selanjutnya adalah mengintegrasikan database ke dalam aplikasi Rocket Framework.
- Menggunakan Fairing untuk Menghubungkan Database: Dalam Rocket, kita dapat menggunakan fairing untuk melakukan inisialisasi dan pembersihan koneksi database saat aplikasi dimulai dan dihentikan.
- Menggunakan Dependensi Database: Tambahkan dependensi database yang dipilih ke dalam Cargo.toml dan gunakan dalam kode aplikasi kita.
D. Contoh Penggunaan Database dalam Aplikasi Web
Untuk memberikan gambaran lebih jelas tentang penggunaan database dalam aplikasi web dengan Rocket Framework, mari kita lihat contoh sederhana bagaimana kita dapat membuat, membaca, memperbarui, dan menghapus data dalam database menggunakan ORM atau query builder.
- Membaca Data dari Database:
#[get("/users")]
async fn get_users() -> Result<Json<Vec<User>>, CustomError> {
let users = User::get_all().await?;
Ok(Json(users))
}Code language: PHP (php)- Menambahkan Data ke Database:
#[post("/users", data = "<user>")]
async fn create_user(user: Json<User>) -> Result<Json<User>, CustomError> {
let new_user = user.into_inner();
let created_user = User::create(new_user).await?;
Ok(Json(created_user))
}Code language: PHP (php)- Memperbarui Data dalam Database:
#[put("/users/<id>", data = "<user>")]
async fn update_user(id: i32, user: Json<User>) -> Result<Json<User>, CustomError> {
let updated_user = User::update(id, user.into_inner()).await?;
Ok(Json(updated_user))
}Code language: PHP (php)- Menghapus Data dari Database:
#[delete("/users/<id>")]
async fn delete_user(id: i32) -> Result<Json<()>, CustomError> {
User::delete(id).await?;
Ok(Json(()))
}Code language: PHP (php)Dengan mengikuti langkah-langkah di atas, kita dapat dengan mudah mengintegrasikan database ke dalam aplikasi web kita dan berinteraksi dengan data dalam database dengan baik. Hal ini memungkinkan kita untuk membuat aplikasi web yang lebih kompleks dan kuat dengan kemampuan penyimpanan dan pengambilan data yang andal. Selanjutnya, kita akan melihat bagaimana kita dapat melakukan konkurensi dengan Rust.
0 Comments