Rust Web 全栈开发（九）：增加教师管理功能

Rust Web 全栈开发（九）：增加教师管理功能

参考视频：https://www.bilibili.com/video/BV1RP4y1G7KF

继续之前的 Actix 项目，项目现状如下所示：

新增教师结构体

在 models 目录下，新建一个 teacher.rs。

为 CreateTeacher 和 UpdateTeacher 分别实现了 From trait。

use actix_web::web;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Debug, Clone, sqlx::FromRow)]
pub struct Teacher {
    pub id: i32,
    pub name: String,
    pub picture_url: String,
    pub profile: String,
}

#[derive(Deserialize, Debug, Clone)]
pub struct CreateTeacher {
    pub name: String,
    pub picture_url: String,
    pub profile: String,
}

impl From<web::Json<CreateTeacher>> for CreateTeacher {
    fn from(new_teacher: web::Json<CreateTeacher>) -> Self {
        CreateTeacher {
            name: new_teacher.name.clone(),
            picture_url: new_teacher.picture_url.clone(),
            profile: new_teacher.profile.clone(),
        }
    }
}

#[derive(Deserialize, Debug, Clone)]
pub struct UpdateTeacher {
    pub name: Option<String>,
    pub picture_url: Option<String>,
    pub profile: Option<String>,
}

impl From<web::Json<UpdateTeacher>> for UpdateTeacher {
    fn from(update_teacher: web::Json<UpdateTeacher>) -> Self {
        UpdateTeacher {
            name: update_teacher.name.clone(),
            picture_url: update_teacher.picture_url.clone(),
            profile: update_teacher.profile.clone(),
        }
    }
}

对应要修改 models/mod.rs，新增：

pub mod teacher;

数据库准备

在名为 course 的 MySQL 数据库中，新建一个名为 teacher 的表：

新增访问 MySQL 数据库中 teacher 表的方法

在 dbaccess 目录下，新建一个 teacher.rs，其中涉及了对 teacher 表增删查改的方法。

use sqlx::MySqlPool;
use crate::errors::MyError;
use crate::models::teacher::{CreateTeacher, Teacher, UpdateTeacher};

pub async fn post_new_teacher_db(pool: &MySqlPool, new_teacher: CreateTeacher) -> Result<(), MyError> {
    let _insert_query = sqlx::query!(
        "INSERT INTO teacher (name, picture_url, profile)
            VALUES (?, ?, ?)",
        new_teacher.name,
        new_teacher.picture_url,
        new_teacher.profile,
    )
        .execute(pool)
        .await?;

    Ok(())
}

pub async fn delete_teacher_db(pool: &MySqlPool, teacher_id: i32) -> Result<String, MyError> {
    let row = sqlx::query!(
        "DELETE FROM teacher
            WHERE id = ?",
        teacher_id,
    )
        .execute(pool)
        .await
        .map_err(|_err| MyError::DBError("Unable to delete teacher".into()))?;

    Ok(format!("Deleted {:?} record", row))
}

pub async fn update_teacher_details_db(
    pool: &MySqlPool,
    teacher_id: i32,
    update_teacher: UpdateTeacher
) -> Result<String, MyError> {
    let current_teacher_row: Teacher = sqlx::query_as(
        "SELECT id, name, picture_url, profile
                FROM teacher
                WHERE id = ?"
    )
        .bind(teacher_id)
        .fetch_one(pool) // 获取单条记录
        .await
        .map_err(|_err| MyError::NotFound("Teacher Id not found".into()))?;

    let teacher = Teacher {
        id: current_teacher_row.id,
        name: if let Some(name) = update_teacher.name {
            name
        } else {
            current_teacher_row.name
        },
        picture_url: if let Some(picture_url) = update_teacher.picture_url {
            picture_url
        } else {
            current_teacher_row.picture_url
        },
        profile: if let Some(profile) = update_teacher.profile {
            profile
        } else {
            current_teacher_row.profile
        },
    };

    let row = sqlx::query!(
        "UPDATE teacher
            SET name = ?, picture_url = ?, profile = ?
            WHERE id = ?",
        teacher.name,
        teacher.picture_url,
        teacher.profile,
        teacher_id,
    )
        .execute(pool)
        .await?;

    Ok(format!("Update {:?} record", row))
}
pub async fn get_all_teachers_db(pool: &MySqlPool) -> Result<Vec<Teacher>, MyError> {
    let rows: Vec<Teacher> = sqlx::query_as(
        "SELECT id, name, picture_url, profile
                FROM teacher"
    )
        .fetch_all(pool) // 获取所有记录
        .await?;

    match rows.len() {
        0 => Err(MyError::NotFound("Teacher not found".into())),
        _ => Ok(rows),
    }
}

pub async fn get_teacher_details_db(pool: &MySqlPool, teacher_id: i32) -> Result<Teacher, MyError> {
    let row = sqlx::query_as(
        "SELECT id, name, picture_url, profile
                FROM teacher
                WHERE id = ?"
    )
        .bind(teacher_id)
        .fetch_one(pool) // 获取单条记录
        .await
        .map(|teacher: Teacher| Teacher {
            id: teacher.id,
            name: teacher.name,
            picture_url: teacher.picture_url,
            profile: teacher.profile,
        })
        .map_err(|_err| MyError::NotFound("Teacher Id not found".into()))?;

    Ok(row)
}

对应要修改 dbaccess/mod.rs，新增：

pub mod teacher;

新增 Handler

在 handlers 目录下，新建一个 teacher.rs。

其中的函数调用 dbaccess/teacher.rs 的方法，得到结果，转换为 HTTP Response。

use std::env;
use std::sync::Mutex;
use actix_web::{web, HttpResponse};
use actix_web::web::Data;
use dotenv::dotenv;
use sqlx::mysql::MySqlPoolOptions;
use crate::errors::MyError;
use crate::state::AppState;
use crate::dbaccess::teacher::*;
use crate::models::teacher::{CreateTeacher, UpdateTeacher};

pub async fn post_new_teacher(
    new_teacher: web::Json<CreateTeacher>,
    app_state: web::Data<AppState>,
) -> Result<HttpResponse, MyError> {
    post_new_teacher_db(&app_state.db, new_teacher.into())
    .await
    .map(|_| HttpResponse::Ok().json("Post new teacher successfully."))
}

pub async fn get_all_teachers(app_state: web::Data<AppState>) -> Result<HttpResponse, MyError> {
    get_all_teachers_db(&app_state.db)
        .await
        .map(|teachers| HttpResponse::Ok().json(teachers))
}

pub async fn get_teacher_detail(
    app_state: web::Data<AppState>,
    params: web::Path<i32>
) -> Result<HttpResponse, MyError> {
    let teacher_id = params.into_inner();
    get_teacher_details_db(&app_state.db, teacher_id)
        .await
        .map(|teacher| HttpResponse::Ok().json(teacher))
}

pub async fn update_teacher_detail(
    app_state: web::Data<AppState>,
    update_teacher: web::Json<UpdateTeacher>,
    params: web::Path<i32>
) -> Result<HttpResponse, MyError> {
    let teacher_id = params.into_inner();
    update_teacher_details_db(&app_state.db, teacher_id, update_teacher.into())
        .await
        .map(|msg| HttpResponse::Ok().json(msg))
}

pub async fn delete_teacher(
    app_state: web::Data<AppState>,
    params: web::Path<i32>
) -> Result<HttpResponse, MyError> {
    let teacher_id = params.into_inner();
    delete_teacher_db(&app_state.db, teacher_id)
        .await
        .map(|msg| HttpResponse::Ok().json(msg))
}

#[cfg(test)]
mod tests {
    use super::*;
    use actix_web::http::StatusCode;
    use std::sync::Mutex;
    use dotenv::dotenv;
    use sqlx::mysql::MySqlPoolOptions;
    use std::env;
    use actix_web::ResponseError;

    // #[ignore]
    #[actix_rt::test]
    async fn post_new_teacher_success() {
        // 检测并读取 .env 文件中的内容，若不存在也会跳过异常
        dotenv().ok();

        let db_url = env::var("DATABASE_URL")
            .expect("DATABASE_URL 没有在 .env 文件里设置");

        // 创建数据库连接池
        let db_pool = MySqlPoolOptions::new()
            .connect(&db_url)
            .await
            .unwrap();

        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let teacher = web::Json(CreateTeacher {
            name: "A New Teacher".into(),
            picture_url: "https://i2.hdslb.com/bfs/article/1f8a3ece569b3d61903fe2062cf71d96435d6f8b.jpg@1192w.avif".into(),
            profile: "This is a test profile".into(),
        });

        // 模拟添加教师的请求
        let response = post_new_teacher(teacher, app_state).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);
    }

    #[actix_rt::test]
    async fn get_all_teachers_success() {
        dotenv().ok();
        let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
        let db_pool = MySqlPoolOptions::new().connect(&db_url).await.unwrap();
        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let response = get_all_teachers(app_state).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);
    }

    #[actix_rt::test]
    async fn get_teacher_detail_success() {
        dotenv().ok();
        let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
        let db_pool = MySqlPoolOptions::new().connect(&db_url).await.unwrap();
        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let params: web::Path<i32> = web::Path::from(1);
        let response = get_teacher_detail(app_state, params).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);
    }

    #[actix_rt::test]
    async fn get_teacher_detail_failure() {
        dotenv().ok();
        let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
        let db_pool = MySqlPoolOptions::new().connect(&db_url).await.unwrap();
        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let params: web::Path<i32> = web::Path::from(100);
        let response = get_teacher_detail(app_state, params).await;

        match response {
            Ok(_) => println!("Something went wrong"),
            Err(err) => assert_eq!(err.status_code(), StatusCode::NOT_FOUND),
        }
    }

    #[actix_rt::test]
    async fn update_teacher_success() {
        dotenv().ok();
        let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
        let db_pool = MySqlPoolOptions::new().connect(&db_url).await.unwrap();
        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let params: web::Path<i32> = web::Path::from(2);
        let update_param = web::Json(UpdateTeacher {
            name: Some("Teacher name changed".into()),
            picture_url: Some("https://i2.hdslb.com/bfs/article/6e82414fa0c96d530caa120caed421240df75cfc.jpg@1192w.avif".into()),
            profile: Some("This is a update profile".into()),
        });
        let response = update_teacher_detail(app_state, update_param, params).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

    }

    // #[ignore]
    #[actix_rt::test]
    async fn delete_teacher_success() {
        dotenv().ok();
        let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
        let db_pool = MySqlPoolOptions::new().connect(&db_url).await.unwrap();
        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let params: web::Path<i32> = web::Path::from(3);
        let response = delete_teacher(app_state, params).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);
    }

    #[actix_rt::test]
    async fn delete_teacher_failure() {
        dotenv().ok();
        let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
        let db_pool = MySqlPoolOptions::new().connect(&db_url).await.unwrap();
        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

        let params: web::Path<i32> = web::Path::from(100);
        let response = delete_teacher(app_state, params).await;

        match response {
            Ok(_) => println!("Something went wrong"),
            Err(err) => assert_eq!(err.status_code(), StatusCode::NOT_FOUND),
        }
    }
}

对应要修改 handlers/mod.rs，新增：

pub mod teacher;

新增 Router

修改 routers.rs，新增关于教师的路由：

pub fn teacher_routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
        web::scope("/teachers")
            .route("/", web::post().to(post_new_teacher))
            .route("/", web::get().to(get_all_teachers))
            .route("/{teacher_id}", web::get().to(get_teacher_detail))
            .route("/{teacher_id}", web::put().to(update_teacher_detail))
            .route("/{teacher_id}", web::delete().to(delete_teacher))
    );
}

修改 Error

修改 errors.rs，在 MyError 中新增一种 InvalidInput 错误类型，表示输入参数错误。

#[derive(Debug, Serialize)]
pub enum MyError {
    DBError(String),
    ActixError(String),
    #[allow(dead_code)]
    NotFound(String),
    InvalidInput(String),
}

对应修改 MyError 的 error_response 方法，以及 error::ResponseError trait 中的 status_code 方法，发生输入参数错误时，返回 HTTP 400 Bad Request。

impl MyError {
    fn error_response(&self) -> String {
        match self {
            MyError::DBError(msg) => {
                println!("Database error occurred: {:?}", msg);
                "Database error".into()
            }
            MyError::ActixError(msg) => {
                println!("Server error occurred: {:?}", msg);
                "Internal server error".into()
            }
            MyError::NotFound(msg) => {
                println!("Not found error occurred: {:?}", msg);
                msg.into()
            }
            MyError::InvalidInput(msg) => {
                println!("Invalid input error occurred: {:?}", msg);
                msg.into()
            }
        }
    }
}

impl error::ResponseError for MyError {
    fn status_code(&self) -> StatusCode {
        match self {
            MyError::DBError(_msg) | MyError::ActixError(_msg) => StatusCode::INTERNAL_SERVER_ERROR,
            MyError::NotFound(_msg) => StatusCode::NOT_FOUND,
            MyError::InvalidInput(_msg) => StatusCode::BAD_REQUEST,
        }
    }

    fn error_response(&self) -> HttpResponse {
        HttpResponse::build(self.status_code()).json(MyErrorResponse {
            error_message: self.error_response(),
        })
    }
}

修改 teacher_service

修改 webservice/bin/teacher_service.rs：

    let app = move || {
        App::new()
            .app_data(shared_data.clone())
            .app_data(web::JsonConfig::default().error_handler(|_err, _req| {
                MyError::InvalidInput("Please provide valid json input".to_string()).into()
            }))
            .configure(general_routes)
            .configure(course_routes)
            .configure(teacher_routes)
    };

Web 应用程序新增 teacher_routes 路由。

在应用程序执行前，先执行输入参数错误的 handler，返回 MyError::InvalidInput 错误信息。

测试

测试前的数据库 teacher 表：

cd 到 webservice，在终端执行命令 cargo test teacher，7 个关于教师的测试都通过了：

测试后的数据库 teacher 表：

可以看出：新插入了一个教师信息，删除了一个教师信息，更新了一个教师信息。

执行命令 cargo run，在浏览器中测试功能：

尾声

修改 handlers/teacher.rs，在 post_new_teacher_success 和 delete_teacher_success 两个测试函数上打上 #[ignore] 注释。

这样在之后执行命令 cargo test 时，会忽略这两个测试。

我们发现在 handlers/teacher.rs 的 test 模块的每一个测试函数中，都有这一段连接 MySQL 数据库、创建 AppState 的代码：

        // 检测并读取 .env 文件中的内容，若不存在也会跳过异常
        dotenv().ok();

        let db_url = env::var("DATABASE_URL")
            .expect("DATABASE_URL 没有在 .env 文件里设置");

        // 创建数据库连接池
        let db_pool = MySqlPoolOptions::new()
            .connect(&db_url)
            .await
            .unwrap();

        let app_state: web::Data<AppState> = web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        });

我们将其提取为两个独立的函数：

    async fn create_db_pool() -> MySqlPool {
        // 检测并读取 .env 文件中的内容，若不存在也会跳过异常
        dotenv().ok();

        let db_url = env::var("DATABASE_URL")
            .expect("DATABASE_URL 没有在 .env 文件里设置");

        // 创建数据库连接池
        MySqlPoolOptions::new()
            .connect(&db_url)
            .await
            .unwrap()
    }

    async fn create_app_state() -> web::Data<AppState> {
        let db_pool = create_db_pool().await;

        web::Data::new(AppState {
            health_check_response: "".to_string(),
            visit_count: Mutex::new(0),
            db: db_pool,
        })
    }

之后，在每一个测试函数中，创建 AppState 都可以用一行代码搞定：

let app_state = create_app_state().await;

同理，对 handlers/course.rs 中的 test 模块也这样优化。