Rustでイベント駆動型Webアプリを効率的に設計・実装する方法

async fn fetch_data() {
    let response = reqwest::get("https://api.example.com/data").await.unwrap();
    println!("Response: {:?}", response.text().await.unwrap());
}

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    println!("Starting the event loop...");

    tokio::spawn(async {
        sleep(Duration::from_secs(3)).await;
        println!("Task 1 completed");
    });

    tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!("Task 2 completed");
    });

    println!("Event loop running...");
    sleep(Duration::from_secs(5)).await;
}

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

#[get("/")]
async fn index() -> impl Responder {
    "Hello, world!"
}

#[actix_web::main]
async fn main() {
    HttpServer::new(|| App::new().service(index))
        .bind("127.0.0.1:8080")
        .unwrap()
        .run()
        .await
        .unwrap();
}

cargo add actix-web

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

// ルートハンドラ
async fn greet() -> impl Responder {
    HttpResponse::Ok().body("Hello, World!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::{web, App, HttpServer, Responder};

async fn greet(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/hello/{name}", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::{middleware, App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(middleware::Logger::default())
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::{web, HttpResponse, Responder};

async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello, World!")
}

use actix_web::{web, HttpResponse, Responder};

async fn greet(name: web::Path<String>) -> impl Responder {
    HttpResponse::Ok().body(format!("Hello, {}!", name))
}

use actix_web::{web, HttpResponse, Responder};
use serde::Deserialize;

#[derive(Deserialize)]
struct Info {
    name: String,
}

async fn submit(info: web::Json<Info>) -> impl Responder {
    HttpResponse::Ok().body(format!("Received: {}", info.name))
}

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

async fn index() -> impl Responder {
    HttpResponse::Ok().body("Hello, World!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(middleware::Logger::default()) // ログ出力のミドルウェア
            .route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_service::{Service, Transform};
use actix_web::{dev::{ServiceRequest, ServiceResponse}, Error, HttpResponse};
use futures::future::{ok, Ready};
use std::task::{Context, Poll};

pub struct CustomMiddleware;

impl<S, B> Transform<S, ServiceRequest> for CustomMiddleware
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Transform = CustomMiddlewareService<S>;
    type InitError = ();
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ok(CustomMiddlewareService { service })
    }
}

pub struct CustomMiddlewareService<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for CustomMiddlewareService<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = S::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&mut self, req: ServiceRequest) -> Self::Future {
        println!("Custom Middleware: Request received");
        self.service.call(req)
    }
}

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

async fn index() -> impl Responder {
    HttpResponse::Ok().body("Hello, World!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(CustomMiddleware) // カスタムミドルウェアを追加
            .route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use tokio::time::{sleep, Duration};

async fn delayed_response() -> impl Responder {
    println!("Starting task...");
    sleep(Duration::from_secs(3)).await; // 3秒待機
    HttpResponse::Ok().body("Task completed after 3 seconds")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/task", web::get().to(delayed_response))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use tokio::task;
use std::time::Duration;

async fn handle_form_submission(data: web::Json<String>) -> impl Responder {
    let user_data = data.into_inner();

    // 非同期タスクでデータベース更新をトリガー
    let db_task = task::spawn(async move {
        println!("Updating database with: {}", user_data);
        tokio::time::sleep(Duration::from_secs(2)).await;
        println!("Database update completed.");
    });

    // 非同期タスクで通知送信をトリガー
    let notification_task = task::spawn(async {
        println!("Sending notification...");
        tokio::time::sleep(Duration::from_secs(1)).await;
        println!("Notification sent.");
    });

    // 両方のタスクが完了するのを待つ
    let _ = tokio::join!(db_task, notification_task);

    HttpResponse::Ok().body("Form submitted successfully!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/submit", web::post().to(handle_form_submission))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use tokio::task;

async fn process_data() -> Result<(), &'static str> {
    let task = task::spawn(async {
        if true { // 任意の条件
            Err("An error occurred in the task")
        } else {
            Ok(())
        }
    });

    match task.await {
        Ok(Ok(())) => println!("Task completed successfully"),
        Ok(Err(e)) => eprintln!("Task error: {}", e),
        Err(e) => eprintln!("Task panicked: {:?}", e),
    }

    Ok(())
}

use actix_web::{web, App, HttpResponse, HttpServer, Responder, Result};

async fn index() -> Result<HttpResponse> {
    let condition = false;

    if condition {
        Ok(HttpResponse::Ok().body("Everything is fine!"))
    } else {
        Err(actix_web::error::ErrorInternalServerError("An internal error occurred"))
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

   Err(actix_web::error::ErrorBadRequest("Invalid request data"))

   Err(actix_web::error::ErrorUnauthorized("Unauthorized access"))

   Err(actix_web::error::ErrorForbidden("Access denied"))

   Err(actix_web::error::ErrorNotFound("Resource not found"))

   Err(actix_web::error::ErrorInternalServerError("Internal server error"))

use actix_web::{error, web, App, HttpResponse, HttpServer, Result};
use serde::Serialize;

#[derive(Serialize)]
struct ErrorResponse {
    error: String,
    message: String,
}

async fn custom_error() -> Result<HttpResponse, actix_web::Error> {
    let error_response = ErrorResponse {
        error: "InternalError".to_string(),
        message: "Something went wrong!".to_string(),
    };
    Err(error::ErrorInternalServerError(web::Json(error_response)))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/error", web::get().to(custom_error))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

   RUST_BACKTRACE=1 cargo run

   cargo run

   let handle = tokio::spawn(async {
       // タスクの処理
   });

   if let Err(e) = handle.await {
       eprintln!("Task failed: {:?}", e);
   }

[dependencies]
actix-web = "4"
actix = "0.13"
actix-web-actors = "4"
serde = { version = "1.0", features = ["derive"] }

use actix::{Actor, StreamHandler};
use actix_web::{get, web, App, Error, HttpRequest, HttpResponse, HttpServer};
use actix_web_actors::ws;

// WebSocketセッションのアクター
struct ChatSession;

impl Actor for ChatSession {
    type Context = ws::WebsocketContext<Self>;
}

// WebSocketメッセージのハンドラ
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for ChatSession {
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Text(text)) => {
                println!("Received message: {}", text);
                ctx.text(format!("Echo: {}", text)); // メッセージをエコーバック
            }
            Ok(ws::Message::Close(reason)) => {
                println!("Client disconnected: {:?}", reason);
                ctx.stop();
            }
            _ => (),
        }
    }
}

// WebSocketハンドラ
#[get("/ws")]
async fn chat_ws(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    ws::start(ChatSession, &req, stream)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(chat_ws) // WebSocketエンドポイント
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

cargo run

let socket = new WebSocket("ws://127.0.0.1:8080/ws");

socket.onopen = () => {
    console.log("Connected to the server");
    socket.send("Hello, Rust!");
};

socket.onmessage = (event) => {
    console.log("Received: ", event.data);
};

socket.onclose = () => {
    console.log("Connection closed");
};

   Received: Echo: Hello, Rust!