Web Development with Rust

# CHAPTER 26

Web Development with Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Install and configure Actix Web and Serde.

• Start an asynchronous HTTP server.

• Define routing endpoints (GET, POST).

• Serialize Rust Structs into JSON responses.

• Extract data from URL paths.

3. Setting Up the Project #

[dependencies]
actix-web = "4"
# Serde allows us to easily convert Structs to JSON and back
serde = { version = "1.0", features = ["derive"] } 

4. Creating a Basic HTTP Server #

use actix_web::{get, App, HttpResponse, HttpServer, Responder};

// 1. Define a Route using a Macro
#[get("/hello")]
async fn hello() -> impl Responder {
    // Return a 200 OK with a text body
    HttpResponse::Ok().body("Hello from the Rust Backend!")
}

// 2. Start the Server
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://localhost:8080/");

    HttpServer::new(|| {
        App::new()
            .service(hello) // Register the route
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

*Run this code, open http://localhost:8080/hello in your browser, and see the result!*

5. Returning JSON (The Magic of Serde) #

use actix_web::{get, web, App, HttpServer, Responder};
use serde::Serialize;

// Derive Serialize so Actix knows how to turn this into JSON
#[derive(Serialize)]
struct User {
    id: u32,
    username: String,
    role: String,
}

#[get("/api/user")]
async fn get_user() -> impl Responder {
    let user = User {
        id: 101,
        username: String::from("alice_dev"),
        role: String::from("admin"),
    };

    // Return 200 OK, but encode the struct as JSON!
    web::Json(user) 
}

*Output when visiting /api/user:* {"id": 101, "username": "alice_dev", "role": "admin"}

6. Extracting URL Path Variables #

// The {} denotes a path variable
#[get("/api/users/{user_id}")]
async fn get_user_by_id(path: web::Path<u32>) -> impl Responder {
    // Extract the variable from the path
    let user_id = path.into_inner();

    // In a real app, query the database using 'user_id' here!

    format!("You requested data for User ID: {}", user_id)
}

7. Handling POST Requests #

use serde::Deserialize;

#[derive(Deserialize)]
struct CreateUserRequest {
    username: String,
}

#[actix_web::post("/api/users")]
async fn create_user(req_body: web::Json<CreateUserRequest>) -> impl Responder {
    // We now have safe, typed access to the JSON payload!
    let new_name = &req_body.username;
    
    // Process and save to database...

    HttpResponse::Created().body(format!("Created user: {}", new_name))
}

8. Common Mistakes #

• Forgetting to Register Services: Writing a route function like async fn login() but forgetting to add .service(login) inside the HttpServer::new closure. The route will return a 404 Not Found.

• Missing Serde Derivations: Trying to return web::Json(mystruct) without adding #[derive(Serialize)] to the struct. The compiler will panic, saying the trait bound is not satisfied.

• Extract Application State: Actix Web allows you to inject shared state (like a Database Connection Pool from Chapter 25) into App::new().appdata(...). This allows all your routes to securely access the database without creating a new connection every time.

10. Exercises #

1. 1. Setup an Actix Web project.

1. 2. Create a struct Product (id, name, price) and derive Serialize.

1. 3. Create a GET route /products that returns a hardcoded Product as JSON.

1. 4. Run the server and test it in your browser.

11. MCQs with Answers #

12. Interview Questions #

• Q: Explain how Serde works with Actix Web to handle JSON serialization and deserialization seamlessly.

• Q: How does Actix handle massive concurrency? (Answer: It utilizes the Tokio async runtime, spawning lightweight tasks to handle incoming requests rather than heavy OS threads).

13. Summary #

14. Next Chapter Recommendation #