mm_mysql 2.0.1 → 2.0.3

package/index.js

@@ -1,444 +1,1031 @@
 /**
- * @fileOverview Mysql帮助类函数
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 1.2
+ * MySQL数据库操作类
+ * @class Mysql
+ * @extends BaseService
  */
-const {
-	createPool
-} = require('mysql2/promise');
-const {
-	DB
-} = require('./db');
+// 添加模块导入检查
+let mysql = require('mysql2/promise');
+const { BaseService } = require('mm_base_service');
+const { DB } = require('./db');
+class Mysql extends BaseService {
+  /**
+   * 默认配置
+   */
+  static default_config = {
+    host: '127.0.0.1',
+    port: 3306,
+    user: 'root',
+    password: '',
+    database: '',
+    charset: 'utf8mb4',
+    timezone: '+08:00',
+    connectTimeout: 20000,  // mysql2原生支持的连接超时
+    acquireTimeout: 20000,  // 自定义获取连接超时
+    queryTimeout: 20000,    // 自定义查询超时
+    connectionLimit: 10,
+    queueLimit: 0,
+    enableKeepAlive: true,
+    keepAliveInitialDelay: 10000,
+    enableReconnect: true,
+    reconnectInterval: 1000,
+    maxReconnectAttempts: 5,  // 最大重连次数
+    waitForConnections: true  // 确保连接池等待连接可用
+  };
 
-const Link_model = require('./link_model');
+  /**
+   * 构造函数
+   * @param {Object} config - 配置对象
+   */
+  constructor(config = {}) {
+    // 修复配置合并问题 - 手动合并配置以确保用户配置优先级
+    const mergedConfig = { ...Mysql.default_config, ...config };
+    super(mergedConfig);
 
-var pools = {};
+    // 确保this.config包含合并后的配置
+    this.config = { ...Mysql.default_config, ...config };
+
+    // 初始化状态
+    this._connection = null; // 单个连接
+    this._pool = null; // 连接池
+    this._status = 'closed'; // closed, connecting, connected
+    this._lastConnectTime = 0;
+    this._reconnecting = false;
+    this._isInited = false;
+    this._isDestroyed = false;
+  }
+}
 
 /**
- * @description 数据库封装
+ * 开始事务
+ * @returns {Promise<Object>} 事务连接对象
  */
-class Mysql {
-	/**
-	 * @description 创建Mysql帮助类函数 (构造函数)
-	 * @param {String} scope 作用域
-	 * @param {String} dir 当前路径
-	 * @constructor
-	 */
-	constructor(scope, dir) {
-		// 作用域
-		this.scope;
-		if (scope) {
-			this.scope = scope;
-		} else {
-			this.scope = $.val.scope + '';
-		}
-		// 当前目录
-		this.dir = __dirname;
-		if (dir) {
-			this.dir = dir;
-		}
-		// 错误提示
-		this.error;
-		/**
-		 * sql语句
-		 */
-		this.sql = "";
-		// 连接池
-		this.pool;
-		// 连接态 0未连接，1已连接
-		this.state = 0;
-
-		// 数据库配置参数
-		this.config = {
-			// 服务器地址
-			host: "127.0.0.1",
-			// 端口号
-			port: 3306,
-			// 连接用户名
-			user: "root",
-			// 连接密码
-			password: "asd123",
-			// 数据库
-			database: "mm",
-			// 是否支持多个sql语句同时操作
-			multipleStatements: false,
-			// // 打印SQL
-			// log: true,
-			// // 排除打印
-			// log_ignore: [1062],
-			// debug: true,
-			// 启用keep-alive，保持连接活跃
-			enableKeepAlive: true,
-			waitForConnections: true,
-			compress: false // 启用压缩
-		};
-
-		// 唯一标识符
-		this.identifier = this.config.host + "/" + this.config.database;
-
-		// 定义当前类, 用于数据库实例化访问
-		var $this = this;
-
-		/**
-		 * @description 查询sql
-		 * @param {String} sql 查询参
-		 * @param {Array} val 替换值
-		 * @return {Promise|Array} 异步构造器, 当await时返回执行结果
-		 */
-		this.run = async function(sql, val) {
-			this.sql = sql;
-			if ($this.config.log) {
-				$.log.debug("SQL：", sql);
-			}
-			var conn;
-			var list = [];
-			try {
-				// 关于连接池初始化，请参阅上文
-				conn = await $this.getConn();
-				const [rows] = await conn.query(sql, val);
-				// 查询解析时，连接会自动释放
-				list = rows;
-			} catch (err) {
-				console.error("mysql查询错误", err);
-				this.error = {
-					code: err.errno,
-					message: err.sqlMessage
-				};
-			} finally {
-				if (conn) conn.release();
-			}
-			return list;
-		};
-
-		/**
-		 * @description 增删改sql
-		 * @param {String} sql 查询参
-		 * @param {Array} val 替换值
-		 * @return {Promise|Array} 异步构造器, 当await时返回执行结果
-		 */
-		this.exec = async function(sql, val) {
-			if (this.task) {
-				this.task_sql += sql + "\n";
-				if (this.task === 1) {
-					return this.task_sql;
-				} else if (this.task === 2) {
-					this.task = 0;
-					sql = this.task_sql.trim();
-					this.task_sql = '';
-				} else {
-					this.task = 0;
-					this.task_sql = '';
-					return;
-				}
-			}
-			this.sql = sql;
-			if ($this.config.log) {
-				$.log.debug("SQL：", sql);
-			}
-			var conn;
-			var bl = -1;
-			try {
-				conn = await $this.getConn();
-				var [rows] = await conn.execute(sql, val);
-				if (rows.constructor == Array) {
-					if (rows.length > 0) {
-						var num = 0;
-						rows.map(function(item) {
-							num += item['affectedRows'];
-						});
-						if (num === 0) {
-							bl = rows.length;
-						} else {
-							bl = num;
-						}
-					} else {
-						bl = 1;
-					}
-				} else {
-					var num = rows['affectedRows'];
-					if (num === 0) {
-						bl = 1;
-					} else {
-						bl = num;
-					}
-				}
-				// 查询解析时，连接会自动释放
-			} catch (err) {
-				console.error("mysql执行错误", err);
-				this.error = {
-					code: err.errno,
-					message: err.sqlMessage
-				};
-			} finally {
-				if (conn) conn.release();
-			}
-
-			return bl;
-		};
-
-		/**
-		 * @description 获取数据库管理器
-		 */
-		this.db = function() {
-			return new DB($this);
-		};
-	}
-}
+Mysql.prototype.beginTransaction = async function () {
+  try {
+    // 检查连接状态
+    if (this._status !== 'connected') {
+      throw new Error('数据库连接未建立');
+    }
 
-Mysql.prototype.getConn = async function() {
-	let conn;
-	try {
-		if (!this.pool) {
-			await this.open();
-		}
-		conn = await this.pool.getConnection();
-	} catch (err) {
-		console.error('Connection failed - retrying: ' + err.message);
-		// 重试逻辑，例如等待一段时间后再次尝试获取连接
-		await new Promise(resolve => setTimeout(resolve, 5000)); // 等待5秒后重试
-		conn = await this.getConn(); // 递归调用直到成功获取连接
-	}
-	return conn;
-}
+    // 获取连接
+    const connection = await this.getConn();
+
+    // 开始事务
+    await connection.beginTransaction();
+
+    if (this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务开始`);
+    }
+
+    // 返回事务连接对象，包含提交和回滚方法
+    return {
+      connection,
+      commit: async () => {
+        await connection.commit();
+        if (this.config.debug) {
+          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务提交`);
+        }
+        // 如果使用连接池，释放连接
+        if (this.config.usePool) {
+          connection.release();
+        }
+      },
+      rollback: async () => {
+        await connection.rollback();
+        if (this.config.debug) {
+          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务回滚`);
+        }
+        // 如果使用连接池，释放连接
+        if (this.config.usePool) {
+          connection.release();
+        }
+      },
+      exec: async (sql, params = []) => {
+        // 在事务中执行SQL，直接实现超时控制
+        const timeout = this.config.queryTimeout || 20000;
+        const queryPromise = connection.query(sql, params);
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`事务查询超时: ${timeout}ms`));
+          }, timeout);
+        });
+
+        const result = await Promise.race([queryPromise, timeoutPromise]);
+        return result[0];
+      }
+    };
+  } catch (error) {
+    $.log.error(`[${this.constructor.name}] [beginTransaction] 事务开始失败`, { error: error.message });
+    throw error;
+  }
+};
 
 /**
- * 导入数据库
- * @param {Object} file sql文件
- * @param {Function} func 回调函数
- * @return {Promise} 异步构造器, 当await时返回执行结果
+ * 在事务中执行多个操作
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>} 回调函数的返回值
  */
-Mysql.prototype.load = async function(file, func) {
-	var count = 0;
-	var progress = 0;
-	var errors = [];
-	var index = 0;
-	try {
-		var data = file.loadText();
-		// 将SQL文件内容分割成单独的语句
-		const arr = data.replace(/\r\n/g, '\n').split(';\n');
-		count = arr.length;
-		for (var i = 0; i < arr.length; i++) {
-			var sql_str = arr[i].trim();
-			if (sql_str !== '') {
-				await this.run(sql_str + ";");
-				if (this.error) {
-					errors.push({
-						sql_str: sql_str.slice(0, 512),
-						error: this.error
-					});
-					// 如果数据库链接失败(密码错误或无法连接)，则退出循环
-					if (this.error.code == 1045 || this.error.code == 2003) {
-						break;
-					}
-				}
-			}
-			var p = i / arr.length;
-			progress = Math.ceil(p * 100);
-			index = i;
-			if (func) {
-				func(progress, index, this.error, sql_str);
-			}
-		}
-	} catch (err) {
-		$.log.error("导入SQL文件失败！", err);
-	}
-	return {
-		index,
-		count,
-		progress,
-		errors
-	}
+Mysql.prototype.transaction = async function (callback) {
+  let transaction = null;
+
+  try {
+    // 开始事务
+    transaction = await this.beginTransaction();
+
+    // 执行回调函数，传入事务对象
+    const result = await callback(transaction);
+
+    // 提交事务
+    await transaction.commit();
+
+    return result;
+  } catch (error) {
+    // 如果有事务，回滚
+    if (transaction) {
+      await transaction.rollback().catch(err => {
+        $.log.error(`[${this.constructor.name}] [transaction] 事务回滚失败`, { error: err.message });
+      });
+    }
+
+    $.log.error(`[${this.constructor.name}] [transaction] 事务执行失败`, { error: error.message });
+    throw error;
+  }
+};
+Mysql.prototype._initService = async function () {
+  if (this._isInited) {
+    $.log.warn('MySQL服务已初始化');
+    return;
+  }
+
+  try {
+    $.log.debug('[Mysql] [_initService]', '初始化MySQL服务', { config: this.config });
+    this._isInited = true;
+    $.log.debug('[Mysql] [_initService]', 'MySQL服务初始化完成');
+  } catch (error) {
+    $.log.error('[Mysql] [_initService]', 'MySQL服务初始化失败', { error: error.message });
+    throw error;
+  }
 };
 
 /**
- * 保存数据库为文件
- * @param {String} file 文件对象
- * @param {Function} func 回调函数
- * @return {Promise} 异步构造器, 当await时返回执行结果
+ * 打开数据库连接
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<boolean>}
  */
-Mysql.prototype.save = async function(file, func, tables = []) {
-	const fs = require('fs');
-	const stream = fs.createWriteStream(file);
-	let count = 0;
-	let progress = 0;
-	let errors = [];
-	let index = 0;
-	let tableCount = 0;
-
-	try {
-		// 开始导出数据库
-		stream.write('SET FOREIGN_KEY_CHECKS = 0;\n\n');
-		count++;
-
-		if (!tables.length) {
-			// 获取所有表
-			var tbs = await this.run('SHOW TABLES');
-			tables = tbs.map((item) => {
-				return item[Object.keys(item)[0]];
-			});
-		}
-
-		tableCount = tables.length;
-		for (var i = 0; i < tables.length; i++) {
-			var tableName = tables[i];
-			try {
-				// 导出表结构
-				const createTable = await this.run(`SHOW CREATE TABLE ${tableName}`);
-				stream.write(`-- 表结构: ${tableName}\n`);
-				stream.write(`DROP TABLE IF EXISTS \`${tableName}\`;\n`);
-				count++;
-				stream.write(`${createTable[0]['Create Table']};\n\n`);
-				count++;
-				// 导出表数据
-				const rows = await this.run(`SELECT * FROM ${tableName}`);
-				if (rows.length > 0) {
-					stream.write(`-- 表数据: ${tableName}\n`);
-					for (const row of rows) {
-						const rowValues = Object.values(row)
-							.map(value => {
-								if (value === null) return 'NULL';
-								if (typeof value === 'boolean') return value ? 1 : 0;
-								if (typeof value === 'number') return value;
-								if (value instanceof Date) {
-									return "'" + value.toStr('yyyy-MM-dd hh:mm:ss') + "'";
-								}
-								// 处理字符串，转义特殊字符
-								return "'" + value.toString()
-									.replace(/[\\']/g, '\\$&')
-									.replace(/\n/g, '\\n')
-									.replace(/\r/g, '\\r')
-									.replace(/\t/g, '\\t')
-									.replace(/\u0000/g, '\\0') + "'";
-							})
-							.join(',');
-						stream.write(`INSERT INTO ${tableName} VALUES (${rowValues});\n`);
-						count++;
-					}
-					stream.write('\n');
-				}
-			} catch (err) {
-				errors.push({
-					table: tableName,
-					error: err.message
-				});
-			}
-
-			index++;
-			progress = Math.ceil((index / tableCount) * 100);
-			if (func) {
-				func(progress, index, this.error, tableName);
-			}
-		}
-
-		// 完成导出
-		stream.write('SET FOREIGN_KEY_CHECKS = 1;\n');
-		count++;
-		stream.end();
-	} catch (err) {
-		$.log.error("导出SQL文件失败！", err);
-		stream.end();
-	}
-
-	return {
-		tableCount,
-		index,
-		count,
-		progress,
-		errors
-	}
+Mysql.prototype.open = async function (timeout = null) {
+  if (this._status === 'connected' || this._status === 'connecting') {
+    $.log.warn('数据库连接已存在或正在连接中');
+    return true;
+  }
+
+  timeout = timeout || this.config.connectTimeout || 10000;
+  this._status = 'connecting';
+
+  try {
+    $.log.debug(`[${this.constructor.name}] [open]`, '开始创建数据库连接', {
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.user,
+      timeout: timeout
+    });
+
+    // 创建连接或连接池
+    const connectionPromise = this._openInternal();
+    // 直接在方法内部实现超时控制
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`数据库连接超时(${timeout}ms)`));
+      }, timeout);
+    });
+
+    try {
+      await Promise.race([connectionPromise, timeoutPromise]);
+
+      this._lastConnectTime = Date.now();
+      this._status = 'connected';
+      $.log.info(`[${this.constructor.name}] [open]`, '数据库连接成功', {
+        host: this.config.host,
+        port: this.config.port,
+        database: this.config.database
+      });
+      return true;
+    } catch (connectionErr) {
+      // 捕获连接过程中的具体错误
+      $.log.error(`[${this.constructor.name}] [open]`, '连接过程错误详情', {
+        error: connectionErr.message,
+        code: connectionErr.code,
+        syscall: connectionErr.syscall,
+        address: connectionErr.address,
+        port: connectionErr.port,
+        stack: connectionErr.stack
+      });
+      throw connectionErr;
+    }
+  } catch (err) {
+    this._status = 'closed';
+    $.log.error(`[${this.constructor.name}] [open]`, '数据库连接失败', {
+      error: err.message,
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database
+    });
+    throw err;
+  }
 };
 
 /**
- * 获取数据库管理器
- * @param {String} key 主键
- * @param {String|Number} value 对象值
- * @param {Boolean} clear_prefix 清除前缀
- * @param {Array} arr_table 关联的数据表
- * @return {Object} 管理模型
+ * 内部连接方法
+ * @private
+ * @returns {Promise<void>}
  */
-Mysql.prototype.dbs = async function(key, value, clear_prefix, ...arr_table) {
-	var lm = new Link_model({
-		key,
-		value,
-		clear_prefix
-	});
-	lm.sql = this;
-	for (var i = 0; i < arr_table.length; i++) {
-		await lm.add(arr_table[i]);
-	}
-	return lm;
+Mysql.prototype._openInternal = function () {
+  return new Promise((resolve, reject) => {
+    // 检查mysql模块是否可用
+    if (!mysql) {
+      const error = new Error('mysql2模块不可用，请先安装依赖: npm install');
+      $.log.error(`[${this.constructor.name}] [_openInternal] 错误:`, error.message);
+      return reject(error);
+    }
+
+    // 配置对象 - 尽量使用mysql2原生支持的配置项
+    const mysqlConfig = {
+      host: this.config.host,
+      port: this.config.port,
+      user: this.config.user,
+      password: this.config.password,
+      database: this.config.database,
+      charset: this.config.charset || 'utf8mb4',
+      timezone: this.config.timezone || '+08:00',
+      connectTimeout: this.config.connectTimeout || 10000,
+      enableKeepAlive: this.config.enableKeepAlive !== false,
+      keepAliveInitialDelay: this.config.keepAliveInitialDelay || 10000,
+      waitForConnections: true
+    };
+
+    // 输出连接配置（隐藏密码）
+    const logConfig = { ...mysqlConfig };
+    logConfig.password = '***';
+    $.log.debug(`[${this.constructor.name}] [_openInternal] 连接配置:`, JSON.stringify(logConfig, null, 2));
+
+    if (this.config.connectionLimit > 1) {
+      // 使用连接池 - 直接使用mysql2原生连接池功能
+      $.log.debug(`[${this.constructor.name}] [_openInternal] 创建连接池`);
+      try {
+        this._pool = mysql.createPool({
+          ...mysqlConfig,
+          connectionLimit: this.config.connectionLimit || 10,
+          queueLimit: this.config.queueLimit || 0,
+          waitForConnections: true
+        });
+
+        // 验证连接池
+        $.log.debug(`[${this.constructor.name}] [_openInternal] 验证连接池连接...`);
+        this._pool.getConnection()
+          .then(conn => {
+            $.log.debug(`[${this.constructor.name}] [_openInternal] 连接池连接验证成功`);
+            conn.release();
+            resolve();
+          })
+          .catch(err => {
+            $.log.error(`[${this.constructor.name}] [_openInternal] 连接池验证失败详情:`, {
+              message: err.message,
+              code: err.code,
+              errno: err.errno,
+              syscall: err.syscall,
+              address: err.address,
+              port: err.port
+            });
+            reject(err);
+          });
+      } catch (poolError) {
+        $.log.error(`[${this.constructor.name}] [_openInternal] 创建连接池失败:`, poolError.message);
+        reject(poolError);
+      }
+    } else {
+      // 使用单个连接
+      $.log.debug(`[${this.constructor.name}] [_openInternal] 创建单个连接`);
+      try {
+        mysql.createConnection(mysqlConfig)
+          .then(conn => {
+            $.log.debug(`[${this.constructor.name}] [_openInternal] 单个连接创建成功`);
+            this._connection = conn;
+            resolve();
+          })
+          .catch(err => {
+            $.log.error(`[${this.constructor.name}] [_openInternal] 单个连接创建失败详情:`, {
+              message: err.message,
+              code: err.code,
+              errno: err.errno,
+              syscall: err.syscall,
+              address: err.address,
+              port: err.port
+            });
+            reject(err);
+          });
+      } catch (connError) {
+        $.log.error(`[${this.constructor.name}] [_openInternal] 创建连接失败:`, connError.message);
+        reject(connError);
+      }
+    }
+  });
 };
 
 /**
- * 设置配置参数
- * @param {Object} cg 配置对象或配置路径
+ * 关闭数据库连接
+ * @returns {Promise<boolean>}
  */
-Mysql.prototype.setConfig = function(cg) {
-	var obj;
-	if (typeof(cg) === "string") {
-		obj = cg.loadJson(this.dir);
-	} else {
-		obj = cg;
-	}
-	$.push(this.config, obj);
-	this.identifier = this.config.host + "/" + this.config.database;
+Mysql.prototype.close = function () {
+  if (this._status !== 'connected') {
+    $.log.warn('数据库连接未建立');
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    try {
+      if (this._pool) {
+        $.log.debug('关闭连接池');
+        this._pool.end(err => {
+          if (err) {
+            $.log.error('关闭连接池失败', { error: err.message });
+          } else {
+            $.log.info('连接池已关闭');
+          }
+          this._pool = null;
+          this._status = 'closed';
+          resolve(!err);
+        });
+      } else if (this._connection) {
+        $.log.debug('关闭单个连接');
+        this._connection.end(err => {
+          if (err) {
+            $.log.error('关闭连接失败', { error: err.message });
+          } else {
+            $.log.info('连接已关闭');
+          }
+          this._connection = null;
+          this._status = 'closed';
+          resolve(!err);
+        });
+      } else {
+        this._status = 'closed';
+        resolve(true);
+      }
+    } catch (err) {
+      $.log.error('关闭数据库连接时发生异常', { error: err.message });
+      this._status = 'closed';
+      resolve(false);
+    }
+  });
 };
 
 /**
- * @description 打开数据库, 如果没有则建立数据库连接再打开
- * @param {boolean} 是否重置
+ * 获取数据库连接
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
  */
-Mysql.prototype.open = function(reset) {
-	if (reset || !this.state || !pools[this.identifier]) {
-		this.state = 1;
-		pools[this.identifier] = createPool(this.config);
-	}
-	this.pool = pools[this.identifier];
+Mysql.prototype.getConn = async function (timeout = null) {
+  // 确定最终超时时间，优先使用传入参数，其次是配置，最后是默认值
+  timeout = timeout || this.config.acquireTimeout || this.config.connectTimeout || 20000;
+
+  // 记录实际使用的超时时间
+  $.log.debug(`[${this.constructor.name}] [getConn] 使用超时时间: ${timeout}ms`);
+
+  if (this._status !== 'connected') {
+    throw new Error('数据库连接未建立');
+  }
+
+  try {
+    // 先检查连接池状态（如果存在）
+    if (this._pool && typeof this._pool._closed !== 'undefined' && this._pool._closed) {
+      $.log.warn('连接池已关闭，尝试重新连接');
+      await this.close();
+      await this.open();
+    }
+
+    // 直接在方法内部实现超时控制
+    const connectionPromise = this._getConnectionInternal();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`获取数据库连接超时(${timeout}ms)`));
+      }, timeout);
+    });
+
+    const conn = await Promise.race([connectionPromise, timeoutPromise]);
+
+    $.log.debug(`[${this.constructor.name}] [getConn] 成功获取数据库连接`);
+
+    // 处理连接错误
+    conn.on('error', (err) => {
+      if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_CONNECTION_LOST' ||
+        err.code === 'POOL_CLOSED' || err.code === 'CONNECTION_TIMED_OUT')) {
+        this._handleConnectionError(err);
+      }
+    });
+
+    return conn;
+  } catch (error) {
+    $.log.error(`[${this.constructor.name}] [getConn] 获取连接失败`, {
+      error: error.message
+    });
+
+    // 处理连接错误
+    if (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT' || error.code === 'PROTOCOL_CONNECTION_LOST' ||
+      error.code === 'POOL_CLOSED' || error.code === 'CONNECTION_TIMED_OUT')) {
+      this._handleConnectionError(error);
+    }
+
+    throw error;
+  }
 };
 
 /**
- * @description 关闭连接
+ * 内部获取连接方法
+ * @private
+ * @returns {Promise<Object>}
  */
-Mysql.prototype.close = function() {
-	if (pools[this.identifier]) {
-		pools[this.identifier].end();
-		pools[this.identifier] = null;
-		delete pools[this.identifier];
-	}
+Mysql.prototype._getConnectionInternal = function () {
+  return new Promise((resolve, reject) => {
+    if (this._pool) {
+      // 从连接池获取连接
+      this._pool.getConnection()
+        .then(conn => {
+          // 设置连接的超时处理
+          conn.on('error', (err) => {
+            $.log.error('数据库连接发生错误', { error: err.message });
+            if (this.config.enableReconnect) {
+              this._handleConnectionError(err);
+            }
+          });
+          resolve(conn);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    } else if (this._connection) {
+      // 返回单个连接
+      resolve(this._connection);
+    } else {
+      reject(new Error('无可用连接'));
+    }
+  });
 };
 
 /**
- * @description 导出Mysql帮助类
+ * 处理连接错误
+ * @private
+ * @param {Error} err - 错误对象
  */
-exports.Mysql = Mysql;
+Mysql.prototype._handleConnectionError = function (err) {
+  if (this._reconnecting) {
+    $.log.debug('重连已在进行中');
+    return;
+  }
+
+  if (this.config.enableReconnect) {
+    $.log.info('开始自动重连...');
+    this._reconnect(this.config.maxReconnectAttempts || 3)
+      .catch(reconnectErr => {
+        $.log.error('重连失败', { error: reconnectErr.message });
+        this._status = 'closed';
+      });
+  } else {
+    $.log.warn('自动重连已禁用');
+    this._status = 'closed';
+  }
+};
+
+/**
+ * 重新连接数据库
+ * @private
+ * @param {Number} maxRetries - 最大重试次数
+ * @returns {Promise<boolean>}
+ */
+Mysql.prototype._reconnect = async function (maxRetries = 3) {
+  if (this._reconnecting) {
+    $.log.warn('重连已在进行中');
+    return false;
+  }
+
+  this._reconnecting = true;
+  let retryCount = 0;
+
+  try {
+    // 先关闭现有连接
+    if (this._status === 'connected') {
+      await this.close();
+    }
+
+    while (retryCount < maxRetries) {
+      retryCount++;
+      $.log.info(`第${retryCount}/${maxRetries}次尝试重连`);
+
+      try {
+        // 使用配置中的超时时间，优先使用connectTimeout，其次是acquireTimeout，最后是默认值20000ms
+        const reconnectTimeout = this.config.connectTimeout || this.config.acquireTimeout || 20000;
+        $.log.debug(`重连超时设置为: ${reconnectTimeout}ms`);
+        await this.open(reconnectTimeout);
+        $.log.info('重连成功');
+        return true;
+      } catch (err) {
+        $.log.error(`重连失败(${retryCount}/${maxRetries})`, { error: err.message });
+
+        if (retryCount < maxRetries) {
+          // 等待一段时间后重试
+          const waitTime = this.config.reconnectInterval || 1000;
+          $.log.debug(`等待${waitTime}ms后重试`);
+          await this._sleep(waitTime);
+        }
+      }
+    }
+
+    $.log.error(`达到最大重试次数(${maxRetries})，重连失败`);
+    throw new Error(`重连失败：达到最大重试次数(${maxRetries})`);
+  } finally {
+    this._reconnecting = false;
+  }
+};
+
+/**
+ * 执行SQL查询
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Mysql.prototype.run = async function (sql, params = [], timeout = null) {
+  let conn = null;
+  let isPoolConn = false;
+  timeout = timeout || this.config.queryTimeout || 30000;
+
+  try {
+    // 获取连接
+    conn = await this.getConn(timeout);
+    isPoolConn = !!this._pool;
+
+    // 直接在方法内部实现超时控制
+    const queryPromise = conn.query(sql, params);
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`SQL查询超时: ${timeout}ms`));
+      }, timeout);
+    });
+
+    const [rows] = await Promise.race([queryPromise, timeoutPromise]);
+
+    // 返回查询结果的第一行或整个结果集，与之前版本兼容
+    return rows;
+  } catch (err) {
+    $.log.error('[Mysql] [run]', 'SQL执行失败', {
+      error: err.message,
+      sql: typeof sql === 'string' ? sql.substring(0, 200) : sql,
+      params: params
+    });
+
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_CONNECTION_LOST')) {
+      this._handleConnectionError(err);
+    }
+
+    throw err;
+  } finally {
+    // 释放连接
+    if (conn && isPoolConn) {
+      try {
+        conn.release();
+      } catch (releaseErr) {
+        $.log.error('释放连接失败', { error: releaseErr.message });
+      }
+    }
+  }
+};
+
+/**
+ * 执行SQL语句（用于执行非查询语句如INSERT/UPDATE/DELETE）
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Mysql.prototype.exec = async function (sql, params = [], timeout = null) {
+  let conn = null;
+  let isPoolConn = false;
+  timeout = timeout || this.config.queryTimeout || 30000;
+
+  try {
+    // 获取连接
+    conn = await this.getConn(timeout);
+    isPoolConn = !!this._pool;
 
+    // 直接在方法内部实现超时控制
+    const queryPromise = conn.query(sql, params);
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`SQL执行超时: ${timeout}ms`));
+      }, timeout);
+    });
+
+    const [rows] = await Promise.race([queryPromise, timeoutPromise]);
+
+    // 对于增删改操作，返回影响的行数
+    return rows.affectedRows || rows.insertId || rows.changedRows || rows;
+  } catch (err) {
+    $.log.error('[Mysql] [exec]', 'SQL执行失败', {
+      error: err.message,
+      sql: sql.substring(0, 200),
+      params: params
+    });
+
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_CONNECTION_LOST')) {
+      this._handleConnectionError(err);
+    }
+
+    throw err;
+  } finally {
+    // 释放连接（如果是从连接池获取的）
+    if (conn && isPoolConn) {
+      try {
+        conn.release();
+      } catch (releaseErr) {
+        $.log.error('释放连接失败', { error: releaseErr.message });
+      }
+    }
+  }
+};
+
+/**
+ * 读取整张表的数据
+ * @param {String} table - 表名
+ * @param {Object} condition - 查询条件
+ * @param {Object} options - 选项（orderBy, limit, offset等）
+ * @returns {Promise<Array>}
+ */
+Mysql.prototype.read = async function (table, condition = {}, options = {}) {
+  try {
+    // 检查连接状态
+    if (this._status !== 'connected') {
+      throw new Error('数据库连接未建立');
+    }
+
+    // 构建基础SQL查询
+    let sql = `SELECT * FROM ${table}`;
+    const params = [];
+
+    // 处理条件
+    if (Object.keys(condition).length > 0) {
+      const whereClauses = [];
+      for (const [field, value] of Object.entries(condition)) {
+        whereClauses.push(`${field} = ?`);
+        params.push(value);
+      }
+      sql += ` WHERE ${whereClauses.join(' AND ')}`;
+    }
+
+    // 处理排序
+    if (options.orderBy) {
+      sql += ` ORDER BY ${options.orderBy}`;
+    }
+
+    // 处理分页
+    if (options.limit) {
+      sql += ` LIMIT ${options.limit}`;
+    }
+
+    if (options.offset) {
+      sql += ` OFFSET ${options.offset}`;
+    }
+
+    // 记录查询日志
+    if (this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [read] 查询数据`, { sql, params });
+    }
+
+    // 执行查询
+    const results = await this.exec(sql, params);
+
+    if (this.config.debug) {
+      $.log.info(`[${this.constructor.name}] [read] 查询成功`, { count: results.length });
+    }
+
+    return results;
+  } catch (error) {
+    // 记录错误日志
+    $.log.error(`[${this.constructor.name}] [read] 查询失败`, {
+      error: error.message,
+      table: table,
+      condition: condition
+    });
+
+    // 抛出错误
+    throw error;
+  }
+};
+
+/**
+ * 保存数据库结构到SQL文件
+ * @param {String} file - 输出文件路径
+ * @param {Array} tables - 要保存的表名数组，空数组表示保存所有表
+ * @returns {Promise<boolean>}
+ */
+Mysql.prototype.save = async function (file, tables = []) {
+  try {
+    let sqlContent = '';
+
+    // 获取所有表名
+    const allTablesResult = await this.run('SHOW TABLES');
+    let tableNames = [];
+
+    if (allTablesResult && allTablesResult.length > 0) {
+      const tableKey = Object.keys(allTablesResult[0])[0];
+      tableNames = allTablesResult.map(row => row[tableKey]);
+    }
+
+    // 过滤要保存的表
+    const tablesToSave = tables.length > 0
+      ? tableNames.filter(name => tables.includes(name))
+      : tableNames;
+
+    // 导出每个表的结构
+    for (const tableName of tablesToSave) {
+      const createSqlResult = await this.run(`SHOW CREATE TABLE \`${tableName}\``);
+      if (createSqlResult && createSqlResult.length > 0) {
+        const createSql = createSqlResult[0]['Create Table'];
+        sqlContent += `\n\n-- Table structure for \`${tableName}\`\n`;
+        sqlContent += createSql + ';\n';
+      }
+    }
+
+    // 确保目录存在
+    file.addDir();
+    file.saveText(sqlContent);
+    $.log.info(`成功导出数据库结构到: ${file}`);
+    return true;
+  } catch (err) {
+    $.log.error(`导出数据库结构失败: ${file}`, { error: err.message });
+    throw err;
+  }
+};
+
+/**
+ * 从SQL文件加载数据库结构和数据
+ * @param {String} file - SQL文件路径
+ * @returns {Promise<boolean>} 是否加载成功
+ */
+Mysql.prototype.load = async function (file) {
+  try {
+    // 记录操作日志
+    if (this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [load] 开始从文件加载数据库`, { 
+        file: file
+      });
+    }
+    
+    // 检查文件是否存在
+    if (!file.hasFile()) {
+      throw new Error(`SQL文件不存在: ${file}`);
+    }
+    
+    // 读取SQL文件内容
+    const sqlContent = file.readText();
+    
+    if (!sqlContent || sqlContent.trim() === '') {
+      throw new Error(`SQL文件内容为空: ${file}`);
+    }
+    
+    // 分割SQL语句（按分号分割，但需要注意处理字符串中的分号）
+    const sqlStatements = this._splitSqlStatements(sqlContent);
+    
+    // 开始事务执行SQL语句
+    await this.exec('START TRANSACTION');
+    
+    try {
+      // 逐个执行SQL语句
+      for (const sql of sqlStatements) {
+        const trimmedSql = sql.trim();
+        if (trimmedSql) {
+          await this.exec(trimmedSql);
+        }
+      }
+      
+      // 提交事务
+      await this.exec('COMMIT');
+      
+      if (this.config.debug) {
+        $.log.info(`[${this.constructor.name}] [load] 数据库加载成功`, { 
+          file: file,
+          statementCount: sqlStatements.length
+        });
+      }
+      
+      return true;
+    } catch (err) {
+      // 回滚事务
+      await this.exec('ROLLBACK').catch(rollbackErr => {
+        $.log.error(`[${this.constructor.name}] [load] 事务回滚失败`, {
+          error: rollbackErr.message
+        });
+      });
+      
+      throw err;
+    }
+  } catch (error) {
+    // 记录错误日志
+    $.log.error(`[${this.constructor.name}] [load] 数据库加载失败`, {
+      error: error.message,
+      file: file
+    });
+    
+    // 抛出错误
+    throw error;
+  }
+};
 
 /**
- * @description mysql连接池
+ * 分割SQL语句
+ * @private
+ * @param {String} sqlContent - SQL内容
+ * @returns {Array} SQL语句数组
  */
+Mysql.prototype._splitSqlStatements = function(sqlContent) {
+  const statements = [];
+  let inString = false;
+  let stringChar = '';
+  let inComment = false;
+  let currentStatement = '';
+  
+  for (let i = 0; i < sqlContent.length; i++) {
+    const char = sqlContent[i];
+    const nextChar = i + 1 < sqlContent.length ? sqlContent[i + 1] : '';
+    
+    // 处理注释
+    if (!inString && !inComment && char === '-' && nextChar === '-') {
+      inComment = true;
+      i++; // 跳过第二个'-'
+      continue;
+    }
+    
+    if (inComment && char === '\n') {
+      inComment = false;
+      continue;
+    }
+    
+    if (inComment) {
+      continue;
+    }
+    
+    // 处理多行注释
+    if (!inString && !inComment && char === '/' && nextChar === '*') {
+      inComment = true;
+      i++; // 跳过'*'
+      continue;
+    }
+    
+    if (inComment && char === '*' && nextChar === '/') {
+      inComment = false;
+      i++; // 跳过'/'
+      continue;
+    }
+    
+    // 处理字符串
+    if (!inComment && (char === "'" || char === '"') && (!inString || stringChar === char)) {
+      // 检查是否是转义的引号
+      let escaped = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (sqlContent[j] === '\\') {
+          escaped = !escaped;
+        } else {
+          break;
+        }
+      }
+      
+      if (!escaped) {
+        if (inString && stringChar === char) {
+          inString = false;
+          stringChar = '';
+        } else if (!inString) {
+          inString = true;
+          stringChar = char;
+        }
+      }
+    }
+    
+    // 分割语句
+    if (!inString && !inComment && char === ';') {
+      statements.push(currentStatement.trim());
+      currentStatement = '';
+    } else {
+      currentStatement += char;
+    }
+  }
+  
+  // 添加最后一个语句（如果有）
+  if (currentStatement.trim()) {
+    statements.push(currentStatement.trim());
+  }
+  
+  return statements;
+};
+
+/**
+ * 获取DB实例（用于高级操作）
+ * @returns {Object} 包含exec、add、set、get、del等方法的数据库操作对象
+ */
+Mysql.prototype.db = function () {
+  if (this._status !== 'connected') {
+    throw new Error('数据库连接未建立');
+  }
+
+  return new DB(this);
+};
+
+/**
+ * 睡眠指定时间（工具方法）
+ * @private
+ * @param {Number} ms - 毫秒数
+ * @returns {Promise<void>}
+ */
+Mysql.prototype._sleep = function (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+/**
+ * @description 销毁MySQL服务，关闭连接池
+ * @async
+ * @returns {Promise<void>}
+ */
+Mysql.prototype.destroy = async function () {
+  if (this._isDestroyed) {
+    $.log.warn('MySQL服务已销毁');
+    return;
+  }
+
+  try {
+    $.log.debug('[Mysql] [destroy]', '开始销毁MySQL服务');
+
+    // 关闭数据库连接
+    if (this._status === 'connected') {
+      await this.close();
+    }
+
+    // 重置状态
+    this._isDestroyed = true;
+    this._isInited = false;
+    this._connection = null;
+    this._pool = null;
+    this._status = 'closed';
+
+    $.log.debug('[Mysql] [destroy]', 'MySQL服务销毁完成');
+  } catch (error) {
+    $.log.error('[Mysql] [destroy]', 'MySQL服务销毁失败', { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * 睡眠指定时间（工具方法）
+ * @private
+ * @param {Number} ms - 毫秒数
+ * @returns {Promise<void>}
+ */
+Mysql.prototype._sleep = function (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+
+/**
+ * 导出模块
+ */
+exports.Mysql = Mysql;
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+  $.pool = {};
+}
 if (!$.pool.mysql) {
-	$.pool.mysql = {};
+  $.pool.mysql = {};
 }
 
 /**
- * @description 缓存管理器，用于创建缓存
+ * @description Mysql管理器，用于创建缓存
  * @param {String} scope 作用域
- * @param {String} dir 当前路径
- * @return {Object} 返回一个缓存类
+ * @param {Object} config 配置参数
+ * @return {Object} 返回一个Mysql类实例
  */
-function mysql_admin(scope, dir) {
-	if (!scope) {
-		scope = $.val.scope
-	}
-	var obj = $.pool.mysql[scope];
-	if (!obj) {
-		$.pool.mysql[scope] = new Mysql(scope, dir);
-		obj = $.pool.mysql[scope];
-	}
-	return obj;
+function mysql_admin(scope, config) {
+  if (!scope) {
+    scope = 'sys';
+  }
+  var obj = $.pool.mysql[scope];
+  if (!obj) {
+    $.pool.mysql[scope] = new Mysql(config);
+    obj = $.pool.mysql[scope];
+  }
+  return obj;
 }
 
 /**
- * @description 导出Mysql管理函数
+ * @module 导出Mysql管理器
  */
 exports.mysql_admin = mysql_admin;