API NodeJS 循环或错误处理问题：池连接未关闭 (MYSQL)？

Question

仍在玩我的第一个 API NodeJS 应用程序。

我当前的 MYSQL 配置是：

const mysql = require('mysql');

  var pool = mysql.createPool({    
    host:'localhost',
    user: 'abc',
    password: 'abc',
    database : 'abc',
    multipleStatements: true,
    connectionLimit: 10
});
  
  


module.exports ={
     connection : pool 
}

我的 'order List' 部分是一种获取未完成订单列表的方法。此页面工作正常，但在单击几个显示列表的按钮后，程序挂起，直到我重新启动 API。

代码：

const express = require('express');
const router = express.Router();
const verify = require('../../verifyToken');
var config = require('../../databaseConfig');
var connection= config.connection;

router.get('/getMainPageCount/',verify,(req,res) => {    
    const chemistID = req.user._id;
  
    connection.getConnection(function(error,tmpConn){
        if(error){

        console.log("error in connecting to MYSQL " + error);
        res.sendStatus(500);

        }else{
        
            var sqlString = "SET @chemistID = ?; CALL getMainPageCount(@chemistID);";
            tmpConn.query(sqlString,[chemistID], async (err,rows,fields)=>{
                try{
                    

                    const ListData = rows[1];
                    
                    
                    //console.log(rows); 
                    //console.log(chemistID); 
                    if (rows && Array.isArray(rows) && rows.length) {

                        return res.status(200).json({
                            
                            Result: true,
                        orders: ListData
                        })  

                    }       
                    else
                    {
                        return res.status(500).json({
                            
                            Result: false
                        })
                    }
                } catch (e) {
                    // this catches any exception in this scope or await rejection
                    console.log(e);
                    res.status(500).json({ Result: e });
                }
            })
        }
    })
});

router.get('/getOpenRequests/',verify,(req,res) => {    
    const chemistID = req.user._id;
    var sqlString = "SET @chemistID = ?; CALL getOpenRequests(@chemistID);";

    connection.getConnection(function(error,tmpConn){
        if(error){

            console.log("error in connecting to MYSQL " + error);
            res.sendStatus(500);

        }else{
            try{
                tmpConn.query(sqlString,[chemistID], async (err,rows,fields)=>{
                    const ListData = rows[1];
                    const foundRows = rows[2][0].rowCount;
                    
                    ////console.log(rows[1][0].FirstName); 
                    //console.log(chemistID); 
                    if (rows && Array.isArray(rows) && rows.length) {

                        return res.status(200).json({
                            
                            Result: true,
                        orders: ListData,
                        rowCount: foundRows})  

                    }       
                    else
                    {
                        return res.status(500).json({
                            
                            Result: false
                        })
                        
                    }
                })
            } catch (e) {
                // this catches any exception in this scope or await rejection
                console.log(e);
                res.status(500).json({ Result: e });
            }
        }
    })
    
    
});

router.get('/getOpenOrders/',verify,(req,res) => {    
    const chemistID = req.user._id;
  var sqlString = "SET @chemistID = ?; CALL getOpenOrders(@chemistID);";

    connection.getConnection(function(error,tmpConn){
        if(error){

            console.log("error in connecting to MYSQL " + error);
            res.sendStatus(500);

        }else{
            try{
                tmpConn.query(sqlString,[chemistID], async (err,rows,fields)=>{
                    const ListData = rows[1];
                    const foundRows = rows[2][0].rowCount;
            
                    //console.log(rows[1][0].FirstName); 
                    
                    if (rows && Array.isArray(rows) && rows.length) {

                        return res.status(200).json({
                            
                            Result: true,
                        orders: ListData,
                        rowCount: foundRows})  

                    }       
                    else
                    {
                        return res.status(500).json({
                            
                            Result: false
                        })
                         
                    }
                })
            } catch (e) {
                // this catches any exception in this scope or await rejection
                console.log(e);
                res.status(500).json({ Result: e });
            }
        }
    })
});

router.get('/getOpenFinalised/',verify,(req,res) => {    
    const chemistID = req.user._id;
    var sqlString = "SET @chemistID = ?; CALL getOpenFinalised(@chemistID);";

    connection.getConnection(function(error,tmpConn){
        if(error){

            console.log("error in connecting to MYSQL " + error);
            res.sendStatus(500);

        }else{
            try{
                tmpConn.query(sqlString,[chemistID], async (err,rows,fields)=>{
                    const ListData = rows[1];
                    const foundRows = rows[2][0].rowCount;
            
                    //console.log(rows[1][0].FirstName); 
                    //console.log(chemistID); 
                    if (rows && Array.isArray(rows) && rows.length) {

                            return res.status(200).json({
                                
                                Result: true,
                                orders: ListData,
                                rowCount: foundRows
                            })  

                    }       
                    else
                    {
                        return res.status(500).json({
                            
                            Result: false
                        })  
                    }
                })
            } catch (e) {
                // this catches any exception in this scope or await rejection
                console.log(e);
                res.status(500).json({ Result: e });
            }
        }
    })
});

router.get('/getOpenOverdue/',verify,(req,res) => {    
    const chemistID = req.user._id;
    var sqlString = "SET @chemistID = ?; CALL getOpenOverdue(@chemistID);";

    connection.getConnection(function(error,tmpConn){
        if(error){

            console.log("error in connecting to MYSQL " + error);
            res.sendStatus(500);

        }else{
            try{
                tmpConn.query(sqlString,[chemistID], async (err,rows,fields)=>{
                    const ListData = rows[1];
                    const foundRows = rows[2][0].rowCount;
                    
                    //console.log(rows[1][0].FirstName); 
                    //console.log(chemistID); 
                    if (rows && Array.isArray(rows) && rows.length) {

                        return res.status(200).json({
                            
                            Result: true,
                        orders: ListData,
                        rowCount: foundRows})  

                    }       
                    else
                    {
                        return res.status(500).json({                        
                        Result: false
                        })
                    }
                })
            } catch (e) {
                // this catches any exception in this scope or await rejection
                console.log(e);
                res.status(500).json({ Result: e });
            }
        }
    })
});

直到我开始使用这个池连接加上错误处理，这个问题才出现。

现在我对 NodeJS（和一般编码）还很陌生，但是如果我运行在终端上这样做：

lsof -i tcp:3000

然后我可以看到那个端口上运行ning 的所有内容。当我使用 ot 执行此操作时（预连接池），我只会得到节点：我的 Listen 的 PID。

现在，在运行任何 API 端点之后大约 10 秒，我得到这个：

COMMAND   PID   USER   FD   TYPE    DEVICE SIZE/OFF NODE NAME
node    18993 myserver 18u  IPv6 198273222      0t0  TCP *:hbci (LISTEN)
node    18993 myserver 19u  IPv6 198273223      0t0  TCP vps.myserver.com.au:hbci->myIPAddress:59264 (ESTABLISHED)

现在我假设连接还在那里...那么连接没有被关闭？这可能是问题所在吗？我只是不明白我的错误处理有什么问题，我得到这个挂起而不是崩溃或其他东西

我不得不更改为池连接，因为它到处都失去了连接，在阅读之后显然池是最好的方式，但我一定是遗漏了什么？我需要释放连接吗？

Answer 1

您正在使用 .getConnection 方法从连接池中获取连接实例。完成连接实例后，您需要使用 connection.release();

关闭连接

如果不这样做，那么这个连接不会被释放，基本上，新请求将没有任何连接可以使用

或者，您可以使用pool.query方法在使用后自动关闭连接。

您可以查看此答案了解更多详情。

API NodeJS 循环或错误处理问题：池连接未关闭 (MYSQL)？

API NodeJS loop or error handling issue: Pool Connections not closing (MYSQL)?

database-connection

node.js

express