node.js判断连接池是否正确连接上的两种方法

方法1：使用连接池的 getConnection() 方法

const mysql = require('mysql2/promise');

async function checkConnectionWithGetConnection() {
    const pool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: 'password',
        database: 'test',
        waitForConnections: true,
        connectionLimit: 10,
        queueLimit: 0
    });

    try {
        // 尝试获取一个连接
        const connection = await pool.getConnection();
        console.log('✅ 数据库连接成功！');

        // 可选：执行一个简单的查询验证
        const [rows] = await connection.query('SELECT 1');
        console.log('✅ 查询验证成功:', rows);

        // 释放连接回连接池
        connection.release();
        return true;
    } catch (error) {
        console.error('❌ 数据库连接失败:', error.message);
        return false;
    }
}

// 使用示例
checkConnectionWithGetConnection();

方法2：使用连接池的 query() 方法进行测试查询

const mysql = require('mysql2/promise');

async function checkConnectionWithQuery() {
    const pool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: 'password',
        database: 'test',
        waitForConnections: true,
        connectionLimit: 10,
        queueLimit: 0
    });

    try {
        // 执行一个简单的测试查询
        const [result] = await pool.query('SELECT 1 AS test_value');
        console.log('✅ 数据库连接成功！测试查询结果:', result);
        return true;
    } catch (error) {
        console.error('❌ 数据库连接失败:', error.message);
        return false;
    } finally {
        // 关闭连接池（在实际应用中，可能不需要立即关闭）
        await pool.end();
    }
}

// 使用示例
checkConnectionWithQuery();

高级用法：封装为可重用的健康检查函数

const mysql = require('mysql2/promise');

class DatabasePool {
    constructor(config) {
        this.pool = mysql.createPool(config);
        this.connected = false;
    }

    async checkConnection() {
        try {
            const connection = await this.pool.getConnection();

            // 验证连接是否有效
            const [rows] = await connection.query('SELECT 1');

            connection.release();
            this.connected = true;

            return {
                success: true,
                message: '数据库连接正常',
                details: {
                    poolStatus: {
                        totalConnections: this.pool._allConnections ? this.pool._allConnections.length : 'N/A',
                        freeConnections: this.pool._freeConnections ? this.pool._freeConnections.length : 'N/A'
                    }
                }
            };
        } catch (error) {
            this.connected = false;
            return {
                success: false,
                message: '数据库连接失败',
                error: error.message
            };
        }
    }

    async healthCheck() {
        try {
            // 方法1：使用测试查询
            const [result] = await this.pool.query('SELECT NOW() AS current_time, VERSION() AS db_version');

            // 检查数据库响应时间
            const startTime = Date.now();
            await this.pool.query('SELECT 1');
            const responseTime = Date.now() - startTime;

            return {
                status: 'healthy',
                dbTime: result[0].current_time,
                version: result[0].db_version,
                responseTime: `${responseTime}ms`,
                timestamp: new Date().toISOString()
            };
        } catch (error) {
            return {
                status: 'unhealthy',
                error: error.message,
                timestamp: new Date().toISOString()
            };
        }
    }

    async close() {
        await this.pool.end();
    }
}

// 使用示例
async function main() {
    const db = new DatabasePool({
        host: 'localhost',
        user: 'root',
        password: 'password',
        database: 'test',
        connectionLimit: 10
    });

    // 检查连接
    const connectionResult = await db.checkConnection();
    console.log('连接检查:', connectionResult);

    if (connectionResult.success) {
        // 健康检查
        const health = await db.healthCheck();
        console.log('健康检查:', health);
    }

    await db.close();
}

main();

区别与建议

两种方法的区别：

建议：

• 应用启动时：使用 getConnection() 方法进行详细的连接验证
• 定期健康检查：使用简单的 SELECT 1 查询
• 生产环境：建议两种方法结合使用，并添加重试逻辑

错误处理增强版：

async function checkConnectionWithRetry(maxRetries = 3, delay = 1000) {
    let lastError;

    for (let i = 0; i < maxRetries; i++) {
        try {
            const result = await checkConnectionWithQuery();
            if (result) {
                console.log(`✅ 第 ${i + 1} 次尝试连接成功`);
                return true;
            }
        } catch (error) {
            lastError = error;
            console.log(`⚠️  第 ${i + 1} 次连接失败，${i < maxRetries - 1 ? `${delay}ms后重试...` : ''}`);

            if (i < maxRetries - 1) {
                await new Promise(resolve => setTimeout(resolve, delay));
                delay *= 2; // 指数退避
            }
        }
    }

    throw new Error(`连接失败，已重试${maxRetries}次: ${lastError.message}`);
}

选择哪种方法取决于具体需求：

• 需要详细控制连接生命周期时使用 getConnection()
• 简单验证连接状态时使用 query()
• 生产环境建议结合使用并添加监控和重试机制