feat(database): 引入数据库连接错误类型并优化错误处理

- 新增 ConnectionError 类型用于封装数据库连接错误
- 修改 establish_connection 函数返回 Result 类型而非直接 panic
- 为 SQLite、MySQL 和 PostgreSQL 连接添加详细的错误信息
- 在应用启动时处理数据库连接和迁移失败的情况
- CLI 和 WebAPI 模块中实现更优雅的错误提示和返回机制
- 添加日志记录以便更好地追踪数据库相关错误

Author: DataEraserC

file_classification_cli/src/main.rs

@@ -34,7 +34,13 @@ fn main() -> Result<(), Box<dyn Error>> {
     let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
     let database_type = std::env::var("DATABASE_TYPE").expect("DATABASE_TYPE must be set");
 
-    let mut conn = database::establish_connection(&database_url, &database_type);
+    let mut conn = match database::establish_connection(&database_url, &database_type) {
+        Ok(conn) => conn,
+        Err(e) => {
+            eprintln!("数据库连接失败: {}", e);
+            return Err(Box::new(e));
+        }
+    };
 
     // 运行待处理的数据库迁移
     if let Err(e) = database::run_pending_migrations(&mut conn, &database_type) {

file_classification_core/src/utils/database.rs

@@ -6,6 +6,42 @@
 
 pub use diesel::{Connection, QueryResult};
 use diesel::RunQueryDsl;
+use std::fmt;
+
+/// 数据库连接错误类型
+#[derive(Debug)]
+pub struct ConnectionError {
+    pub message: String,
+    pub source: Option<Box<dyn std::error::Error + Send + Sync>>,
+}
+
+impl fmt::Display for ConnectionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for ConnectionError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.source.as_ref().map(|e| e.as_ref() as &(dyn std::error::Error + 'static))
+    }
+}
+
+impl ConnectionError {
+    pub fn new(message: &str) -> Self {
+        ConnectionError {
+            message: message.to_string(),
+            source: None,
+        }
+    }
+    
+    pub fn with_source(message: &str, source: Box<dyn std::error::Error + Send + Sync>) -> Self {
+        ConnectionError {
+            message: message.to_string(),
+            source: Some(source),
+        }
+    }
+}
 
 /// 通用数据库连接枚举
 ///
@@ -34,57 +70,75 @@ pub enum AnyConnection {
 /// - `database_type`: 数据库类型
 ///
 /// 返回值：
-/// 成功时返回封装好的数据库连接对象，失败时会 panic 并输出错误信息
-pub fn establish_connection(database_url: &str, database_type: &str) -> AnyConnection {
+/// 成功时返回封装好的数据库连接对象，失败时返回 ConnectionError 错误
+pub fn establish_connection(database_url: &str, database_type: &str) -> Result<AnyConnection, ConnectionError> {
     // 根据数据库类型建立相应的连接
     match database_type {
         #[cfg(feature = "sqlite")]
         "sqlite" => {
-            let mut conn = AnyConnection::Sqlite(
-                diesel::SqliteConnection::establish(database_url)
-                    .unwrap_or_else(|_| panic!("Error connecting to {}", database_url)),
-            );
+            let conn = diesel::SqliteConnection::establish(database_url)
+                .map_err(|e| ConnectionError::with_source(
+                    &format!("Error connecting to SQLite database at {}", database_url),
+                    Box::new(e)
+                ))?;
+            
+            let mut any_conn = AnyConnection::Sqlite(conn);
 
             // 关闭外键约束检查
             diesel::sql_query("PRAGMA foreign_keys = OFF")
-                .execute(&mut conn)
-                .expect("Error executing PRAGMA foreign_keys = OFF");
+                .execute(&mut any_conn)
+                .map_err(|e| ConnectionError::with_source(
+                    "Error executing PRAGMA foreign_keys = OFF",
+                    Box::new(e)
+                ))?;
 
-            conn
+            Ok(any_conn)
         },
 
         #[cfg(feature = "mysql")]
         "mysql" => {
-            let mut conn = AnyConnection::Mysql(
-                diesel::MysqlConnection::establish(database_url)
-                    .unwrap_or_else(|_| panic!("Error connecting to {}", database_url)),
-            );
+            let conn = diesel::MysqlConnection::establish(database_url)
+                .map_err(|e| ConnectionError::with_source(
+                    &format!("Error connecting to MySQL database at {}", database_url),
+                    Box::new(e)
+                ))?;
+            
+            let mut any_conn = AnyConnection::Mysql(conn);
 
             // 关闭外键约束检查
             diesel::sql_query("SET FOREIGN_KEY_CHECKS = 0")
-                .execute(&mut conn)
-                .expect("Error executing SET FOREIGN_KEY_CHECKS = 0");
+                .execute(&mut any_conn)
+                .map_err(|e| ConnectionError::with_source(
+                    "Error executing SET FOREIGN_KEY_CHECKS = 0",
+                    Box::new(e)
+                ))?;
 
-            conn
+            Ok(any_conn)
         },
 
         #[cfg(feature = "postgres")]
         "postgres" => {
-            let mut conn = AnyConnection::Postgresql(
-                diesel::PgConnection::establish(database_url)
-                    .unwrap_or_else(|_| panic!("Error connecting to {}", database_url)),
-            );
+            let conn = diesel::PgConnection::establish(database_url)
+                .map_err(|e| ConnectionError::with_source(
+                    &format!("Error connecting to PostgreSQL database at {}", database_url),
+                    Box::new(e)
+                ))?;
+            
+            let mut any_conn = AnyConnection::Postgresql(conn);
 
             // 关闭外键约束检查
             diesel::sql_query("SET session_replication_role = 'replica'")
-                .execute(&mut conn)
-                .expect("Error executing SET session_replication_role = 'replica'");
+                .execute(&mut any_conn)
+                .map_err(|e| ConnectionError::with_source(
+                    "Error executing SET session_replication_role = 'replica'",
+                    Box::new(e)
+                ))?;
 
-            conn
+            Ok(any_conn)
         },
 
-        // 不支持的数据库类型直接 panic
-        _ => panic!("Unsupported database type: {} or feature not enabled", database_type),
+        // 不支持的数据库类型
+        _ => Err(ConnectionError::new(&format!("Unsupported database type: {} or feature not enabled", database_type))),
     }
 }
 

file_classification_webapi/src/bin/file_classification_webapi.rs

@@ -4,17 +4,30 @@ mod utils;
 use crate::utils::logger::setup_logger;
 use crate::utils::server;
 use crate::utils::app_config::AppConfig;
+use log::error;
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     // 初始化日志记录器
-    setup_logger().expect("日志系统初始化失败");
+    if let Err(e) = setup_logger() {
+        eprintln!("日志系统初始化失败: {}", e);
+        return Err(std::io::Error::new(std::io::ErrorKind::Other, "日志系统初始化失败"));
+    }
 
     // 加载应用配置
-    let config = AppConfig::load().expect("应用配置加载失败");
+    let config = match AppConfig::load() {
+        Ok(config) => config,
+        Err(e) => {
+            error!("应用配置加载失败: {}", e);
+            return Err(std::io::Error::new(std::io::ErrorKind::Other, "应用配置加载失败"));
+        }
+    };
 
     // 运行数据库迁移
-    config.run_migrations().expect("数据库迁移失败");
+    if let Err(e) = config.run_migrations() {
+        error!("数据库迁移失败: {}", e);
+        return Err(std::io::Error::new(std::io::ErrorKind::Other, "数据库迁移失败"));
+    }
 
     // 启动服务器
     server::start_server(config).await

file_classification_webapi/src/bin/utils/app_config.rs

@@ -1,7 +1,7 @@
 use std::env;
 use log;
 use file_classification_common::env_loader::load_env_file;
-use file_classification_core::utils::database::{establish_connection, run_pending_migrations};
+use file_classification_core::utils::database::{establish_connection, run_pending_migrations, ConnectionError};
 use std::error::Error;
 
 #[derive(Clone)]
@@ -44,7 +44,11 @@ impl AppConfig {
     }
 
     pub fn run_migrations(&self) -> Result<(), Box<dyn Error>> {
-        let mut conn = establish_connection(&self.database_url, &self.database_type);
+        let mut conn = establish_connection(&self.database_url, &self.database_type)
+            .map_err(|e| {
+                log::error!("数据库连接失败: {}", e);
+                e
+            })?;
         if let Err(e) = run_pending_migrations(&mut conn, &self.database_type) {
             log::error!("数据库迁移失败: {}", e);
             return Err(e);