21、Rust Web 应用：课程管理与异步编程探索

Rust Web 应用：课程管理与异步编程探索

1. 使用 HTTP POST 方法创建资源

在进行课程创建之前，我们需要先确保路由已正确建立，HTTP 请求能被路由到正确的处理函数。接下来，我们要在处理函数中实现为导师添加课程的逻辑。

首先，启动后端导师 Web 服务，进入第 6 章的代码仓库（ /path-to-chapter6-folder/ezytutors/tutor-db ），使用以下命令启动服务：

cargo run --bin iter5

之后，我们要对项目中的文件进行修改。在 $PROJECT_ROOT/src/iter6/model.rs 文件中添加以下内容：

#[derive(Deserialize, Debug, Clone)]
pub struct NewCourse {
    pub course_name: String,
    pub course_description: String,
    pub course_format: String,
    pub course_duration: String,
    pub course_structure: Option<String>,
    pub course_price: Option<i32>,
    pub course_language: Option<String>,
    pub course_level: Option<String>,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct NewCourseResponse {
    pub course_id: i32,
    pub tutor_id: i32,
    pub course_name: String,
    pub course_description: String,
    pub course_format: String,
    pub course_structure: Option<String>,
    pub course_duration: String,
    pub course_price: Option<i32>,
    pub course_language: Option<String>,
    pub course_level: Option<String>,
    pub posted_time: String,
}

impl From<web::Json<NewCourseResponse>> for NewCourseResponse {
    fn from(new_course: web::Json<NewCourseResponse>) -> Self {
        NewCourseResponse {
            tutor_id: new_course.tutor_id,
            course_id: new_course.course_id,
            course_name: new_course.course_name.clone(),
            course_description: new_course.course_description.clone(),
            course_format: new_course.course_format.clone(),
            course_structure: new_course.course_structure.clone(),
            course_duration: new_course.course_duration.clone(),
            course_price: new_course.course_price,
            course_language: new_course.course_language.clone(),
            course_level: new_course.course_level.clone(),
            posted_time: new_course.posted_time.clone(),
        }
    }
}

use actix_web::web;

这里定义了两个结构体 NewCourse 和 NewCourseResponse ，分别用于表示用户提供的创建新课程的数据和从后端导师 Web 服务接收到的新课程创建响应。同时，实现了 From 特征，用于将从导师 Web 服务接收到的 JSON 数据转换为 NewCourseResponse 结构体。

接下来，在 $PROJECT_ROOT/src/iter6/handler/course.rs 文件中重写处理函数以创建新课程。添加以下模块导入：

use actix_web::{web, Error, HttpResponse, Result};
use crate::state::AppState;
use crate::model::{NewCourse, NewCourseResponse, UpdateCourse, UpdateCourseResponse};
use serde_json::json;
use crate::state::AppState;

然后修改 handle_insert_course 处理函数：

pub async fn handle_insert_course(
    _tmpl: web::Data<tera::Tera>,
    _app_state: web::Data<AppState>,
    path: web::Path<i32>,
    params: web::Json<NewCourse>,
) -> Result<HttpResponse, Error> {
    let tutor_id = path.into_inner();
    let new_course = json!({
        "tutor_id": tutor_id,
        "course_name": &params.course_name,
        "course_description": &params.course_description,
        "course_format": &params.course_format,
        "course_structure": &params.course_structure,
        "course_duration": &params.course_duration,
        "course_price": &params.course_price,
        "course_language": &params.course_language,
        "course_level": &params.course_level
    });
    let awc_client = awc::Client::default();
    let res = awc_client
      .post("http://localhost:3000/courses/")
      .send_json(&new_course)
      .await
      .unwrap()
      .body()
      .await?;
    println!("Finished call: {:?}", res);
    let course_response: NewCourseResponse = serde_json::from_str(
        &std::str::from_utf8(&res)?)?;
    Ok(HttpResponse::Ok().json(course_response))
}

在这个处理函数中，我们从 HTTP 请求中提取路径参数（ tutor_id ）和 JSON 数据参数，构造一个新的 JSON 对象并发送到后端导师 Web 服务。最后将服务返回的 JSON 数据转换为 NewCourseResponse 结构体，并返回 HTTP 响应。

构建并运行 Web SSR 客户端：

cargo run --bin iter6-ssr

使用 curl 请求测试新课程的创建：

curl -X POST localhost:8080/courses/new/1 -d '{"course_name":"Rust web development", "course_description":"Teaches how to write web apps in Rust", "course_format":"Video", "course_duration":"3 hours", "course_price":100}' -H "Content-Type: application/json"

通过以下命令验证新课程是否已添加：

curl localhost:3000/courses/1

2. 使用 HTTP PUT 方法更新资源

在更新课程之前，我们需要在 $PROJECT_ROOT/src/iter6/model.rs 文件中定义更新课程的数据结构：

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct UpdateCourse {
    pub course_name: Option<String>,
    pub course_description: Option<String>,
    pub course_format: Option<String>,
    pub course_duration: Option<String>,
    pub course_structure: Option<String>,
    pub course_price: Option<i32>,
    pub course_language: Option<String>,
    pub course_level: Option<String>,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct UpdateCourseResponse {
    pub course_id: i32,
    pub tutor_id: i32,
    pub course_name: String,
    pub course_description: String,
    pub course_format: String,
    pub course_structure: String,
    pub course_duration: String,
    pub course_price: i32,
    pub course_language: String,
    pub course_level: String,
    pub posted_time: String,
}

impl From<web::Json<UpdateCourseResponse>> for UpdateCourseResponse {
    fn from(new_course: web::Json<UpdateCourseResponse>) -> Self {
        UpdateCourseResponse {
            tutor_id: new_course.tutor_id,
            course_id: new_course.course_id,
            course_name: new_course.course_name.clone(),
            course_description: new_course.course_description.clone(),
            course_format: new_course.course_format.clone(),
            course_structure: new_course.course_structure.clone(),
            course_duration: new_course.course_duration.clone(),
            course_price: new_course.course_price,
            course_language: new_course.course_language.clone(),
            course_level: new_course.course_level.clone(),
            posted_time: new_course.posted_time.clone(),
        }
    }
}

这里定义了 UpdateCourse 和 UpdateCourseResponse 结构体，分别用于捕获用户修改的课程信息和存储从导师 Web 服务接收到的课程更新请求数据。同样实现了 From 特征，用于将 JSON 数据转换为 UpdateCourseResponse 结构体。

接下来，在 $PROJECT_ROOT/src/iter6/handler/course.rs 文件中重写更新课程详情的处理函数：

pub async fn handle_update_course(
    _tmpl: web::Data<tera::Tera>,
    _app_state: web::Data<AppState>,
    web::Path((tutor_id, course_id)): web::Path<(i32, i32)>,
    params: web::Json<UpdateCourse>,
) -> Result<HttpResponse, Error> {
    let update_course = json!({
        "course_name": &params.course_name,
        "course_description": &params.course_description,
        "course_format": &params.course_format,
        "course_duration": &params.course_duration,
        "course_structure": &params.course_structure,
        "course_price": &params.course_price,
        "course_language": &params.course_language,
        "course_level": &params.course_level,
    });
    let awc_client = awc::Client::default();
    let update_url = format!("http://localhost:3000/courses/{}/{}", tutor_id, course_id);
    let res = awc_client
      .put(update_url)
      .send_json(&update_course)
      .await
      .unwrap()
      .body()
      .await?;
    let course_response: UpdateCourseResponse = serde_json::from_str(
        &std::str::from_utf8(&res)?)?;
    Ok(HttpResponse::Ok().json(course_response))
}

use crate::model::{NewCourse, NewCourseResponse, UpdateCourse, UpdateCourseResponse};

在这个处理函数中，我们构造 JSON 数据并发送到导师 Web 服务以更新课程详情，最后将响应数据转换为 UpdateCourseResponse 结构体并返回 HTTP 响应。

构建并运行 Web SSR 客户端：

cargo run --bin iter6-ssr

使用 curl 请求测试课程更新：

curl -X PUT -d '{"course_name":"Rust advanced web development", "course_description":"Teaches how to write advanced web apps in Rust", "course_format":"Video", "course_duration":"4 hours", "course_price":100}' localhost:8080/courses/1/27 -H "Content-Type: application/json"

通过以下命令验证课程详情是否已更新：

curl localhost:3000/courses/1

3. 使用 HTTP DELETE 方法删除资源

在 $PROJECT_ROOT/src/iter6/handler/course.rs 文件中更新处理函数以删除课程：

pub async fn handle_delete_course(
    _tmpl: web::Data<tera::Tera>,
    _app_state: web::Data<AppState>,
    path: web::Path<(i32, i32)>,
) -> Result<HttpResponse, Error> {
    let (tutor_id, course_id) = path.into_inner();
    let awc_client = awc::Client::default();
    let delete_url = format!("http://localhost:3000/courses/{}/{}", tutor_id, course_id);
    let _res = awc_client.delete(delete_url).send().await.unwrap();
    Ok(HttpResponse::Ok().body("Course deleted"))
}

在这个处理函数中，我们从路径参数中提取 tutor_id 和 course_id ，构造删除 URL 并发送 DELETE 请求到导师 Web 服务，最后返回确认信息。

构建并运行导师 Web 应用：

cargo run --bin iter6-ssr

使用 curl 请求删除课程：

curl -X DELETE localhost:8080/courses/delete/1/19

通过以下命令验证课程是否已删除：

curl localhost:3000/courses/1

4. 课程管理操作流程总结

操作类型	处理函数	请求方法	关键步骤
创建课程	handle_insert_course	POST	提取参数、构造 JSON 对象、发送请求、处理响应
更新课程	handle_update_course	PUT	构造 JSON 数据、构造 URL、发送请求、处理响应
删除课程	handle_delete_course	DELETE	提取参数、构造 URL、发送请求、返回确认信息

5. 异步编程相关概念及后续探索

在前面的课程管理操作中，我们已经构建了一个使用 Rust 编写的 Web 应用，它可以与后端 Web 服务通信，与本地数据库交互，并根据传入的 HTTP 请求对数据执行基本的创建、更新和删除操作。

接下来，我们将探索一些高级主题，这些主题虽然与我们目前构建的导师 Web 服务和 Web 应用没有直接关系，但对于构建复杂的 Rust 服务器并为生产部署做准备非常重要。

异步编程是现代系统中至关重要的话题，它允许开发者在数据处理活动时间差异较大或系统存在延迟时，充分利用计算资源。在分布式系统中，异步编程更为重要。我们将从并发编程的简要概述开始，然后查看如何在 Rust 中编写多线程和异步程序的示例，深入研究 Rust 的异步原语，如 futures ，并从第一原则出发学习如何编写异步程序。

此外，我们还将探讨对等（P2P）架构，P2P 架构进一步基于异步编程，虽然对于简单的低流量 Web 应用不是必需的，但 Rust 在高级分布式架构中具有巨大潜力。最后，我们将学习如何使用 Docker 部署基于 Rust 的 Web 应用，利用 Docker 的灵活性和其他优势，使我们的应用能够高效、灵活地部署。

通过这些高级主题的学习，我们将能够应用所学知识开发不同类型的异步应用，并使用 Docker 部署任何类型的 Rust 服务器或应用。

以下是课程管理操作的简单流程图：

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px
    classDef decision fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px

    A([开始]):::startend --> B(创建课程):::process
    B --> C(更新课程):::process
    C --> D(删除课程):::process
    D --> E([结束]):::startend

在完成课程的创建、更新和删除操作后，我们可以尝试以下额外任务：
- 实现一个新的路由以检索导师的课程列表。
- 创建用于创建、更新和删除课程的 HTML 和 Tera 模板。
- 为无效用户输入的情况添加额外的错误处理。

当所有这些元素到位后，我们的应用将更接近完成，并且我们可以自豪地说，项目中最困难的部分已经完成！

Rust Web 应用：课程管理与异步编程探索

6. 异步编程基础

异步编程在现代系统中扮演着至关重要的角色，尤其是在处理大量并发请求的场景下，能极大地提高资源利用率和系统响应性能。在详细探讨异步 Rust 之前，我们先来了解一下并发编程的基本概念。

并发编程允许程序同时执行多个任务，常见的实现方式有多线程和异步编程。多线程通过创建多个线程来并行执行任务，每个线程有自己的执行上下文和栈空间。而异步编程则是通过异步任务的协作，在单个线程或少量线程上实现高效的并发处理。

下面是一个简单的多线程程序示例：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("This is a new thread!");
    });

    handle.join().unwrap();
    println!("Main thread is done.");
}

在这个示例中，我们使用 thread::spawn 创建了一个新线程，并在新线程中打印了一条消息。主线程通过 handle.join() 等待新线程执行完毕。

而异步编程在 Rust 中主要通过 futures 来实现。 futures 是一种表示异步计算结果的抽象，它可以在某个时间点完成并返回值。下面是一个简单的异步函数示例：

use futures::executor::block_on;

async fn hello_world() {
    println!("Hello, world!");
}

fn main() {
    block_on(hello_world());
}

在这个示例中， hello_world 是一个异步函数，使用 async 关键字定义。 block_on 函数用于阻塞当前线程，直到异步任务完成。

7. 深入理解 Rust 中的 Futures

Futures 是 Rust 异步编程的核心概念，它代表一个可能还未完成的异步操作。一个 Future 可以处于三种状态之一：未完成、完成或被取消。

Future 特征定义如下：

pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

pub enum Poll<T> {
    Ready(T),
    Pending,
}

poll 方法用于检查 Future 的状态，如果 Future 已经完成，返回 Poll::Ready 并携带结果；如果还未完成，返回 Poll::Pending 。

下面是一个自定义 Future 的示例：

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

struct MyFuture {
    counter: u32,
}

impl Future for MyFuture {
    type Output = u32;

    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        if self.counter < 10 {
            self.counter += 1;
            Poll::Pending
        } else {
            Poll::Ready(self.counter)
        }
    }
}

#[tokio::main]
async fn main() {
    let my_future = MyFuture { counter: 0 };
    let result = my_future.await;
    println!("Result: {}", result);
}

在这个示例中，我们定义了一个自定义的 Future MyFuture ，它会在 counter 达到 10 时完成。在 poll 方法中，我们检查 counter 的值，如果小于 10 则返回 Poll::Pending ，否则返回 Poll::Ready 。

8. 对等（P2P）架构探索

对等（P2P）架构是一种分布式系统架构，其中每个节点既是客户端又是服务器，节点之间直接进行通信和数据交换。P2P 架构在文件共享、分布式计算等领域有广泛应用。

在 Rust 中，由于其强大的并发和异步编程能力，非常适合构建 P2P 应用。与传统的客户端 - 服务器架构相比，P2P 架构具有更好的可扩展性和容错性。

以下是 P2P 架构与传统客户端 - 服务器架构的对比表格：
| 架构类型 | 特点 | 优势 | 劣势 |
| ---- | ---- | ---- | ---- |
| 客户端 - 服务器架构 | 有一个中心服务器，客户端与服务器通信 | 易于管理和维护，安全性较高 | 服务器成为瓶颈，扩展性有限 |
| P2P 架构 | 节点之间直接通信，无中心服务器 | 可扩展性强，容错性好 | 管理和安全性较复杂 |

9. 使用 Docker 部署 Rust 应用

Docker 是一种容器化技术，它可以将应用及其依赖打包成一个独立的容器，确保应用在不同环境中具有一致的运行效果。使用 Docker 部署基于 Rust 的 Web 应用可以提高部署的效率和灵活性。

以下是使用 Docker 部署 Rust 应用的基本步骤：
1. 编写 Dockerfile ：创建一个 Dockerfile 文件，用于定义 Docker 镜像的构建过程。

# 基础镜像
FROM rust:latest

# 创建工作目录
WORKDIR /app

# 复制项目文件
COPY . .

# 构建项目
RUN cargo build --release

# 暴露端口
EXPOSE 8080

# 运行应用
CMD ["cargo", "run", "--release"]

2. 构建 Docker 镜像 ：在项目根目录下执行以下命令构建 Docker 镜像。

docker build -t my-rust-app .

3. 运行 Docker 容器 ：使用以下命令运行 Docker 容器。

docker run -p 8080:8080 my-rust-app

通过以上步骤，我们可以将 Rust 应用打包成 Docker 镜像，并在 Docker 容器中运行。

10. 总结与展望

通过本文，我们学习了如何使用 Rust 构建一个 Web 应用，实现课程的创建、更新和删除操作。同时，我们还探索了异步编程、 futures 、P2P 架构和 Docker 部署等高级主题。

异步编程和 P2P 架构为我们提供了处理高并发和分布式系统的有效手段，而 Docker 则使我们的应用能够高效、灵活地部署。在未来的开发中，我们可以将这些技术应用到更复杂的项目中，构建出性能卓越、可扩展性强的 Rust 服务器和应用。

以下是整个学习过程的流程图：

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px
    classDef decision fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px

    A([开始]):::startend --> B(课程管理操作):::process
    B --> C(异步编程学习):::process
    C --> D(P2P 架构探索):::process
    D --> E(Docker 部署):::process
    E --> F([结束]):::startend

希望本文能帮助你更好地理解 Rust Web 应用开发和相关高级技术，让你在 Rust 编程的道路上更进一步！