Node.js MySQL需要持久连接

Question

Node.js MySQL需要持久连接

44

我需要为我的Node Web应用程序创建一个持久的MySQL连接。问题在于，这种情况每天会发生几次：

Error: Connection lost: The server closed the connection.
at Protocol.end (/var/www/n/node_modules/mysql/lib/protocol/Protocol.js:73:13)
at Socket.onend (stream.js:79:10)
at Socket.EventEmitter.emit (events.js:117:20)
at _stream_readable.js:895:16
at process._tickCallback (node.js:415:13)
error: Forever detected script exited with code: 8
error: Forever restarting script for 2 time
info: socket.io started

这是我的连接代码：

// Yes I know multipleStatements can be dangerous in the wrong hands.
var sql = mysql.createConnection({
    host: 'localhost',
    user: 'my_username',
    password: 'my_password',
    database: 'my_database',
    multipleStatements: true
});

sql.connect();

function handleDisconnect(connection) {
    connection.on('error', function(err) {
        if (!err.fatal) {
            return;
        }
        if (err.code !== 'PROTOCOL_CONNECTION_LOST') {
            throw err;
        }
        console.log('Re-connecting lost connection: ' + err.stack);
        sql = mysql.createConnection(connection.config);
        handleDisconnect(sql);
        sql.connect();
    });
}

handleDisconnect(sql);

正如您所看到的，handleDisconnect代码不起作用。

- apscience

知道你在Node中使用的MySQL模块会有所帮助。 - Sly

1

我正在使用标签提供的node-mysql。 - apscience

啊，抱歉。我没在标签中看到它。 - Sly

3个回答

34

我知道这个回答有点晚了，但是我写了一个解决方案，我认为它可能更通用和可用。我的应用完全依赖于connection.query() ，而转换到池后，这些调用就会失败。

这是我的解决方案：

var mysql = require('mysql');

var pool = mysql.createPool({
    host     : 'localhost',
    user     : 'user',
    password : 'secret',
    database : 'test',
    port     : 3306
});

module.exports = {
    query: function(){
        var sql_args = [];
        var args = [];
        for(var i=0; i<arguments.length; i++){
            args.push(arguments[i]);
        }
        var callback = args[args.length-1]; //last arg is callback
        pool.getConnection(function(err, connection) {
        if(err) {
                console.log(err);
                return callback(err);
            }
            if(args.length > 2){
                sql_args = args[1];
            }
        connection.query(args[0], sql_args, function(err, results) {
          connection.release(); // always put connection back in pool after last query
          if(err){
                    console.log(err);
                    return callback(err);
                }
          callback(null, results);
        });
      });
    }
};

这将实例化池，然后导出一个名为query的方法。现在，无论何时调用connection.query()，它都会调用此方法，该方法首先从池中获取连接，然后将参数传递给该连接。它还具有首先获取回调的附加效果，因此它可以回调任何从池中获取连接时的错误。

要使用它，只需将其作为模块要求并放置在mysql的位置。例如：

var connection = require('../middleware/db');

function get_active_sessions(){
  connection.query('Select * from `sessions` where `Active`=1 and Expires>?;', [~~(new Date()/1000)], function(err, results){
    if(err){
      console.log(err);
    }
    else{
      console.log(results);
    }
  });
}

这看起来就像普通的查询，但实际上它会在后台打开一个连接池并获取连接。

- Adam Yost

1

一个使用案例会更有帮助 :) - tomexsans

非常好的解决方案，特别是当您需要暂停特定连接时。 - Adam Fowler

帮了我很大的忙。我正在使用这个解决方案。谢谢你。 - Natan

21

回答 @gladsocc 的问题：

有没有一种方法可以在不重构所有内容的情况下使用池？我的应用中有数十个 SQL 查询。

我最终构建了这个。它是查询函数的包装器。它将获取连接，执行查询，然后释放连接。

var pool = mysql.createPool(config.db);

exports.connection = {
    query: function () {
        var queryArgs = Array.prototype.slice.call(arguments),
            events = [],
            eventNameIndex = {};

        pool.getConnection(function (err, conn) {
            if (err) {
                if (eventNameIndex.error) {
                    eventNameIndex.error();
                }
            }
            if (conn) { 
                var q = conn.query.apply(conn, queryArgs);
                q.on('end', function () {
                    conn.release();
                });

                events.forEach(function (args) {
                    q.on.apply(q, args);
                });
            }
        });

        return {
            on: function (eventName, callback) {
                events.push(Array.prototype.slice.call(arguments));
                eventNameIndex[eventName] = callback;
                return this;
            }
        };
    }
};

我使用它的方式与平常一样。

db.connection.query("SELECT * FROM `table` WHERE `id` = ? ", row_id)
          .on('result', function (row) {
            setData(row);
          })
          .on('error', function (err) {
            callback({error: true, err: err});
          });

- Vlad Goran

我刚试过了这个，但是我得到了 ReferenceError: db is not defined 的错误信息。 - Brandy

@BrandonStewart 在第二个代码示例中，你在另一个文件中，因此你需要像平常一样获取连接，即在顶部的某个地方使用 var db = require('./db.js');。 - Vlad Goran

它完美地运行了，非常感谢您的帮助。 - Ger

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Daniel · Accepted Answer

使用 MySQL 连接池。它将在连接断开时重新连接，您还可以同时进行多个 SQL 查询。如果不使用数据库池，您的应用程序将在等待当前正在运行的数据库请求完成时阻塞数据库请求。

我通常定义一个数据库模块，在其中将查询与路由分离。它看起来像这样...

var mysql = require('mysql');
var pool  = mysql.createPool({
  host     : 'example.org',
  user     : 'bob',
  password : 'secret'
});

exports.getUsers = function(callback) {
  pool.getConnection(function(err, connection) {
    if(err) { 
      console.log(err); 
      callback(true); 
      return; 
    }
    var sql = "SELECT id,name FROM users";
    connection.query(sql, [], function(err, results) {
      connection.release(); // always put connection back in pool after last query
      if(err) { 
        console.log(err); 
        callback(true); 
        return; 
      }
      callback(false, results);
    });
  });
});