fix: use DbPool

Author: DataEraserC

Cargo.lock

@@ -19,6 +19,8 @@ diesel = { version = "2.2", features = [
 #    "postgres",
     "chrono",
     "returning_clauses_for_sqlite_3_35",
+    "r2d2",
 ] }
 dotenvy = "0.15"
 chrono = { version = "0.4", features = ["serde"] }
+serde = { version = "1.0.219", features = ["derive"] }

Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 diesel = { workspace = true }
 dotenvy = { workspace = true }
 chrono = { workspace = true }
-serde = { version = "1.0.219", features = ["derive"] }
+serde = { workspace = true }
 #mysqlclient-sys = { workspace = true }
 #libsqlite3-sys = { workspace = true }
 #openssl-sys = { workspace = true }

file_classification_core/Cargo.toml

@@ -5,11 +5,14 @@ edition = "2024"
 
 [dependencies]
 file_classification_core = { path = "../file_classification_core" }
-chrono = { workspace = true, version = "0.4.41", features = ["serde"] }
+chrono = { workspace = true }
+serde = { workspace = true }
+#diesel = { workspace = true, features = ["r2d2"] }
+diesel = { workspace = true }
+dotenvy = { workspace = true }
+# web related deps
 actix-web = "4.11.0"
-serde = { version = "1.0.219", features = ["derive"] }
 lazy_static = "1.5.0"
-diesel = { version = "2.2.12", features = ["r2d2"] }
 serde_json = "1.0.142"
 once_cell = "1.21.3"
 env_logger = "0.11.8"

file_classification_webapi/Cargo.toml

@@ -1,16 +1,20 @@
 use actix_web::{web, App, HttpServer, middleware::Logger};
-use file_classification_core::utils::database::establish_connection;
 mod handlers;
 mod utils;
+
+use utils::database::establish_connection_pool;
+
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     env_logger::init();
 
     println!("正在启动文件分类 Web API...");
 
-    HttpServer::new(|| {
+    let pool = establish_connection_pool();
+
+    HttpServer::new(move || {
         App::new()
-            .app_data(web::Data::new(establish_connection()))
+            .app_data(web::Data::new(pool.clone()))
             .wrap(Logger::default())
             .service(handlers::files::api_list_files)
             .service(handlers::files::api_list_files_by_conditions)

file_classification_webapi/src/bin/file_classification_webapi.rs

@@ -2,16 +2,16 @@ use actix_web::{get, post, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::FileGroupCondition, service::file_group::{select_file_groups_by_conditions, create_file_group, delete_file_group}, utils};
 use file_classification_core::model::models::FileGroupDTO;
-// TODO: 自己创建数据库
-use file_classification_core::utils::database::establish_connection;
+use crate::utils::database::{DbPool, DbPooledConnection};
 use crate::utils::models::{ApiResponse, ApiError};
 
 
 #[get("/api/file-groups")]
 async fn api_list_file_groups_by_conditions(
     conditions: web::Json<Vec<FileGroupCondition>>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_file_groups_by_conditions(&mut conn, conditions.into_inner(), Some(100)) {
         Ok(file_groups) => {
             let count = file_groups.len();
@@ -32,8 +32,9 @@ async fn api_list_file_groups_by_conditions(
 #[post("/api/file-groups")]
 async fn api_create_file_group(
     file_group_dto: web::Json<FileGroupDTO>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match create_file_group(&mut conn, file_group_dto.into_inner()) {
         Ok(_) => Ok(HttpResponse::Created().json(json!({
             "success": true,
@@ -49,8 +50,9 @@ async fn api_create_file_group(
 #[delete("/api/file-groups")]
 async fn api_delete_file_group(
     file_group_dto: web::Json<FileGroupDTO>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match delete_file_group(&mut conn, file_group_dto.into_inner()) {
         Ok(_) => Ok(HttpResponse::Ok().json(json!({
             "success": true,

file_classification_webapi/src/bin/handlers/file_groups.rs

@@ -1,12 +1,16 @@
 use actix_web::{get, post, put, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::{FileCondition, UpdateFileDTO, FileFilter}, service::files::{select_files, select_files_by_conditions, update_files_by_conditions, delete_file}, utils};
-use crate::utils::models::{ApiResponse, ApiError};
+use file_classification_core::service::files::create_file;
+use crate::utils::database::{DbPool, DbPooledConnection};
+use crate::utils::models::{ApiResponse, ApiError, CreateFileDTO};
+
 #[get("/api/files")]
 async fn api_list_files(
     query: web::Query<FileFilter>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_files(&mut conn, query.into_inner(), 100) {
         Ok(files) => {
             let count = files.len();
@@ -27,8 +31,9 @@ async fn api_list_files(
 #[post("/api/files/search")]
 async fn api_list_files_by_conditions(
     conditions: web::Json<Vec<FileCondition>>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_files_by_conditions(&mut conn, conditions.into_inner(), Some(100)) {
         Ok(files) => {
             let count = files.len();
@@ -49,15 +54,16 @@ async fn api_list_files_by_conditions(
 // #[post("/api/files")]
 // async fn api_create_file(
 //     file_dto: web::Json<CreateFileDTO>,
+//     pool: web::Data<DbPool>,
 // ) -> Result<HttpResponse> {
 //     let create_dto = file_classification_core::model::models::CreateFileDTO {
 //         type_: &file_dto.type_,
 //         path: &file_dto.path,
 //         group_id: file_dto.group_id,
 //     };
 //
-//     let mut conn = utils::database::establish_connection();
-//     match create_file(&mut conn, &create_dto) {
+//     let mut conn = pool.get().expect("Failed to get connection from pool");
+//     match create_file(&mut conn, create_dto) {
 //         Ok(file) => Ok(HttpResponse::Created().json(ApiResponse::from(file))),
 //         Err(e) => Ok(HttpResponse::InternalServerError().json(ApiError {
 //             success: false,
@@ -69,10 +75,11 @@ async fn api_list_files_by_conditions(
 #[put("/api/files")]
 async fn api_update_files_by_conditions(
     payload: web::Json<(Vec<FileCondition>, UpdateFileDTO)>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let (conditions, update_dto) = payload.into_inner();
 
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match update_files_by_conditions(&mut conn, conditions, update_dto) {
         Ok(count) => Ok(HttpResponse::Ok().json(json!({
             "success": true,
@@ -89,10 +96,11 @@ async fn api_update_files_by_conditions(
 #[delete("/api/files/{id}")]
 async fn api_delete_file(
     path: web::Path<i32>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let file_id = path.into_inner();
 
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match delete_file(&mut conn, file_id) {
         Ok(_) => Ok(HttpResponse::Ok().json(json!({
             "success": true,

file_classification_webapi/src/bin/handlers/files.rs

@@ -2,13 +2,15 @@ use actix_web::{get, post, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::GroupTagCondition, service::group_tag::{select_group_tags_by_conditions, create_group_tag, delete_group_tag_by_id}, utils};
 use file_classification_core::model::models::GroupTagDTO;
+use crate::utils::database::{DbPool, DbPooledConnection};
 use crate::utils::models::{CreateGroupTagDTO, ApiResponse, ApiError};
 
 #[get("/api/group-tags")]
 async fn api_list_group_tags_by_conditions(
     conditions: web::Json<Vec<GroupTagCondition>>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_group_tags_by_conditions(&mut conn, conditions.into_inner(), Some(100)) {
         Ok(group_tags) => {
             let count = group_tags.len();
@@ -29,8 +31,9 @@ async fn api_list_group_tags_by_conditions(
 #[post("/api/group-tags")]
 async fn api_create_group_tag(
     group_tag_dto: web::Json<GroupTagDTO>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match create_group_tag(&mut conn, group_tag_dto.into_inner()) {
         Ok(_) => Ok(HttpResponse::Created().json(json!({
             "success": true,
@@ -46,8 +49,9 @@ async fn api_create_group_tag(
 #[delete("/api/group-tags")]
 async fn api_delete_group_tag(
     group_tag_dto: web::Json<GroupTagDTO>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match delete_group_tag_by_id(&mut conn, group_tag_dto.into_inner()) {
         Ok(_) => Ok(HttpResponse::Ok().json(json!({
             "success": true,

file_classification_webapi/src/bin/handlers/group_tags.rs

@@ -1,13 +1,15 @@
 use actix_web::{get, post, put, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::{GroupCondition, UpdateGroupDTO, GroupFilter}, service::groups::{select_groups, select_groups_by_conditions, create_group, update_groups_by_conditions, delete_group}, utils};
+use crate::utils::database::{DbPool, DbPooledConnection};
 use crate::utils::models::{CreateGroupDTO, ApiResponse, ApiError};
 
 #[get("/api/groups")]
 async fn api_list_groups(
     query: web::Query<GroupFilter>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_groups(&mut conn, query.into_inner(), 100) {
         Ok(groups) => {
             let count = groups.len();
@@ -28,8 +30,9 @@ async fn api_list_groups(
 #[post("/api/groups/search")]
 async fn api_list_groups_by_conditions(
     conditions: web::Json<Vec<GroupCondition>>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_groups_by_conditions(&mut conn, conditions.into_inner(), Some(100)) {
         Ok(groups) => {
             let count = groups.len();
@@ -50,8 +53,9 @@ async fn api_list_groups_by_conditions(
 #[post("/api/groups")]
 async fn api_create_group(
     group_dto: web::Json<CreateGroupDTO>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match create_group(&mut conn, &group_dto.name) {
         Ok(group) => Ok(HttpResponse::Created().json(ApiResponse::from(group))),
         Err(e) => Ok(HttpResponse::InternalServerError().json(ApiError {
@@ -64,10 +68,11 @@ async fn api_create_group(
 #[put("/api/groups")]
 async fn api_update_groups_by_conditions(
     payload: web::Json<(Vec<GroupCondition>, UpdateGroupDTO)>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let (conditions, update_dto) = payload.into_inner();
 
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match update_groups_by_conditions(&mut conn, conditions, update_dto) {
         Ok(count) => Ok(HttpResponse::Ok().json(json!({
             "success": true,
@@ -84,10 +89,11 @@ async fn api_update_groups_by_conditions(
 #[delete("/api/groups/{id}")]
 async fn api_delete_group(
     path: web::Path<i32>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let group_id = path.into_inner();
 
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match delete_group(&mut conn, group_id) {
         Ok(_) => Ok(HttpResponse::Ok().json(json!({
             "success": true,

file_classification_webapi/src/bin/handlers/groups.rs

@@ -1,13 +1,15 @@
 use actix_web::{get, post, put, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::{TagCondition, UpdateTagDTO, TagFilter}, service::tags::{select_tags, select_tags_by_conditions, create_tag, update_tags_by_conditions, delete_tag}, utils};
+use crate::utils::database::{DbPool, DbPooledConnection};
 use crate::utils::models::{CreateTagDTO, ApiResponse, ApiError};
 
 #[get("/api/tags")]
 async fn api_list_tags(
     query: web::Query<TagFilter>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_tags(&mut conn, query.into_inner(), 100) {
         Ok(tags) => {
             let count = tags.len();
@@ -28,8 +30,9 @@ async fn api_list_tags(
 #[post("/api/tags/search")]
 async fn api_list_tags_by_conditions(
     conditions: web::Json<Vec<TagCondition>>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match select_tags_by_conditions(&mut conn, conditions.into_inner(), Some(100)) {
         Ok(tags) => {
             let count = tags.len();
@@ -50,8 +53,9 @@ async fn api_list_tags_by_conditions(
 #[post("/api/tags")]
 async fn api_create_tag(
     tag_dto: web::Json<CreateTagDTO>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match create_tag(&mut conn, &tag_dto.name) {
         Ok(tag) => Ok(HttpResponse::Created().json(ApiResponse::from(tag))),
         Err(e) => Ok(HttpResponse::InternalServerError().json(ApiError {
@@ -64,9 +68,10 @@ async fn api_create_tag(
 #[put("/api/tags")]
 async fn api_update_tags_by_conditions(
     payload: web::Json<(Vec<TagCondition>, UpdateTagDTO)>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let (conditions, update_dto) = payload.into_inner();
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
 
     match update_tags_by_conditions(&mut conn, conditions, update_dto) {
         Ok(count) => Ok(HttpResponse::Ok().json(json!({
@@ -84,10 +89,11 @@ async fn api_update_tags_by_conditions(
 #[delete("/api/tags/{id}")]
 async fn api_delete_tag(
     path: web::Path<i32>,
+    pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let tag_id = path.into_inner();
 
-    let mut conn = utils::database::establish_connection();
+    let mut conn = pool.get().expect("Failed to get connection from pool");
     match delete_tag(&mut conn, tag_id) {
         Ok(_) => Ok(HttpResponse::Ok().json(json!({
             "success": true,