Rust Web框架：构建现代化Web应用

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
 
async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello world!")
}
 
async fn echo(req_body: String) -> impl Responder {
    HttpResponse::Ok().body(req_body)
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(hello))
            .route("/echo", web::post().to(echo))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::{web, App, HttpResponse, HttpServer};
use serde::{Deserialize, Serialize};
 
#[derive(Debug, Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}
 
async fn create_user(user: web::Json<User>) -> HttpResponse {
    HttpResponse::Ok().json(user.into_inner())
}
 
async fn get_user(id: web::Path<u32>) -> HttpResponse {
    let user = User {
        id: id.into_inner(),
        name: String::from("John Doe"),
        email: String::from("john@example.com"),
    };
    HttpResponse::Ok().json(user)
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(
                web::scope("/api")
                    .route("/users", web::post().to(create_user))
                    .route("/users/{id}", web::get().to(get_user))
            )
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::middleware::{Logger, NormalizePath};
use actix_web::{error, middleware, web, App, Error, HttpResponse};
 
#[derive(Debug, Serialize)]
struct ErrorResponse {
    code: u16,
    message: String,
}
 
async fn protected_resource() -> Result<HttpResponse, Error> {
    Err(error::ErrorUnauthorized("需要认证"))
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    std::env::set_var("RUST_LOG", "actix_web=info");
    env_logger::init();
 
    HttpServer::new(|| {
        App::new()
            .wrap(Logger::default())
            .wrap(NormalizePath::default())
            .app_data(web::JsonConfig::default().limit(4096))
            .service(
                web::resource("/protected")
                    .route(web::get().to(protected_resource))
            )
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

#[macro_use] extern crate rocket;
 
#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}
 
#[get("/hello/<name>")]
fn hello(name: &str) -> String {
    format!("Hello, {}!", name)
}
 
#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![index, hello])
}

use sqlx::PgPool;
use actix_web::{web, App, HttpResponse, HttpServer};
 
struct AppState {
    db: PgPool,
}
 
async fn get_users(data: web::Data<AppState>) -> HttpResponse {
    match sqlx::query!("SELECT id, name, email FROM users")
        .fetch_all(&data.db)
        .await
    {
        Ok(users) => HttpResponse::Ok().json(users),
        Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
    }
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let pool = PgPool::connect("postgres://user:pass@localhost/dbname")
        .await
        .expect("无法连接到数据库");
 
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(AppState { db: pool.clone() }))
            .route("/users", web::get().to(get_users))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix::{Actor, StreamHandler};
use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer};
use actix_web_actors::ws;
 
struct MyWebSocket;
 
impl Actor for MyWebSocket {
    type Context = ws::WebsocketContext<Self>;
}
 
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWebSocket {
    fn handle(
        &mut self,
        msg: Result<ws::Message, ws::ProtocolError>,
        ctx: &mut Self::Context,
    ) {
        match msg {
            Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
            Ok(ws::Message::Text(text)) => ctx.text(text),
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            _ => (),
        }
    }
}
 
async fn websocket_route(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    ws::start(MyWebSocket {}, &req, stream)
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/ws", web::get().to(websocket_route))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_multipart::Multipart;
use actix_web::{web, App, Error, HttpResponse, HttpServer};
use futures::{StreamExt, TryStreamExt};
use std::io::Write;
 
async fn upload(mut payload: Multipart) -> Result<HttpResponse, Error> {
    // 迭代处理上传的文件
    while let Ok(Some(mut field)) = payload.try_next().await {
        let content_type = field.content_disposition();
        let filename = content_type
            .get_filename()
            .map_or_else(|| "unknown".to_string(), |f| f.to_string());
 
        // 创建文件
        let mut f = std::fs::File::create(filename.clone())?;
 
        // 写入文件内容
        while let Some(chunk) = field.next().await {
            let data = chunk?;
            f.write_all(&data)?;
        }
    }
 
    Ok(HttpResponse::Ok().body("文件上传成功"))
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/upload", web::post().to(upload))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}