node.js + tổng hợp kết nối mysql

Question 1

Tôi đang cố gắng tìm ra cách cấu trúc ứng dụng của mình để sử dụng MySQL một cách hiệu quả nhất. Tôi đang sử dụng mô-đun node-mysql. Các chủ đề khác ở đây được đề xuất sử dụng gộp kết nối vì vậy tôi thiết lập một mô-đun nhỏ mysql.js

var mysql = require('mysql');

var pool  = mysql.createPool({
    host     : 'localhost',
    user     : 'root',
    password : 'root',
    database : 'guess'
});

exports.pool = pool;

Bây giờ bất cứ khi nào tôi muốn truy vấn mysql, tôi yêu cầu mô-đun này và sau đó truy vấn databse

var mysql = require('../db/mysql').pool;

var test = function(req, res) {
     mysql.getConnection(function(err, conn){
         conn.query("select * from users", function(err, rows) {
              res.json(rows);
         })
     })
}

Cách tiếp cận này có tốt không? Tôi thực sự không thể tìm thấy quá nhiều ví dụ về việc sử dụng kết nối mysql ngoài một ví dụ rất đơn giản nơi mọi thứ được thực hiện trong tập lệnh app.js chính vì vậy tôi không thực sự biết quy ước / phương pháp hay nhất là gì.

Tôi có nên luôn sử dụng connect.end () sau mỗi truy vấn không? Nếu tôi quên nó ở đâu đó thì sao?

Làm cách nào để viết lại phần xuất của mô-đun mysql của tôi để trả về chỉ một kết nối để tôi không phải viết getConnection () mỗi lần?

Question 2

Đó là một cách tiếp cận tốt.

Nếu bạn chỉ muốn có kết nối, hãy thêm mã sau vào mô-đun của bạn, nơi có nhóm:

var getConnection = function(callback) {
    pool.getConnection(function(err, connection) {
        callback(err, connection);
    });
};

module.exports = getConnection;

Bạn vẫn phải viết getConnection mỗi lần. Nhưng bạn có thể lưu kết nối trong mô-đun lần đầu tiên bạn nhận được.

Đừng quên ngắt kết nối khi bạn sử dụng xong:

connection.release();

Question 3

Bạn nên tránh sử dụng pool.getConnection()nếu bạn có thể. Nếu bạn gọi pool.getConnection(), bạn phải gọi connection.release()khi bạn sử dụng xong kết nối. Nếu không, ứng dụng của bạn sẽ gặp khó khăn khi chờ đợi mãi mãi các kết nối được trả về nhóm sau khi bạn đạt đến giới hạn kết nối.

Đối với các truy vấn đơn giản, bạn có thể sử dụng pool.query(). Cách viết tắt này sẽ tự động gọi connection.release()cho bạn — ngay cả trong điều kiện lỗi.

function doSomething(cb) {
  pool.query('SELECT 2*2 "value"', (ex, rows) => {
    if (ex) {
      cb(ex);
    } else {
      cb(null, rows[0].value);
    }
  });
}

Tuy nhiên, trong một số trường hợp bạn phải sử dụng pool.getConnection(). Những trường hợp này bao gồm:

Thực hiện nhiều truy vấn trong một giao dịch.
Chia sẻ các đối tượng dữ liệu như bảng tạm thời giữa các truy vấn tiếp theo.

Nếu bạn phải sử dụng pool.getConnection(), hãy đảm bảo bạn gọi connection.release()bằng mẫu tương tự như bên dưới:

function doSomething(cb) {
  pool.getConnection((ex, connection) => {
    if (ex) {
      cb(ex);
    } else {
      // Ensure that any call to cb releases the connection
      // by wrapping it.
      cb = (cb => {
        return function () {
          connection.release();
          cb.apply(this, arguments);
        };
      })(cb);
      connection.beginTransaction(ex => {
        if (ex) {
          cb(ex);
        } else {
          connection.query('INSERT INTO table1 ("value") VALUES (\'my value\');', ex => {
            if (ex) {
              cb(ex);
            } else {
              connection.query('INSERT INTO table2 ("value") VALUES (\'my other value\')', ex => {
                if (ex) {
                  cb(ex);
                } else {
                  connection.commit(ex => {
                    cb(ex);
                  });
                }
              });
            }
          });
        }
      });
    }
  });
}

Cá nhân tôi thích sử dụng Promises và useAsync()mẫu. Mẫu này kết hợp với async/ awaitkhiến việc vô tình quên release()kết nối sẽ khó hơn rất nhiều vì nó biến phạm vi từ vựng của bạn thành một cuộc gọi tự động tới .release():

async function usePooledConnectionAsync(actionAsync) {
  const connection = await new Promise((resolve, reject) => {
    pool.getConnection((ex, connection) => {
      if (ex) {
        reject(ex);
      } else {
        resolve(connection);
      }
    });
  });
  try {
    return await actionAsync(connection);
  } finally {
    connection.release();
  }
}

async function doSomethingElse() {
  // Usage example:
  const result = await usePooledConnectionAsync(async connection => {
    const rows = await new Promise((resolve, reject) => {
      connection.query('SELECT 2*4 "value"', (ex, rows) => {
        if (ex) {
          reject(ex);
        } else {
          resolve(rows);
        }
      });
    });
    return rows[0].value;
  });
  console.log(`result=${result}`);
}

Question 4

Bạn sẽ thấy trình bao bọc này hữu ích :)

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;
            }
        };
    }
};

Yêu cầu nó, sử dụng nó như thế này:

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});
          });

Question 5

Tôi đang sử dụng kết nối lớp cơ sở này với mysql:

"base.js"

var mysql   = require("mysql");

var pool = mysql.createPool({
    connectionLimit : 10,
    host: Config.appSettings().database.host,
    user: Config.appSettings().database.username,
    password: Config.appSettings().database.password,
    database: Config.appSettings().database.database
});


var DB = (function () {

    function _query(query, params, callback) {
        pool.getConnection(function (err, connection) {
            if (err) {
                connection.release();
                callback(null, err);
                throw err;
            }

            connection.query(query, params, function (err, rows) {
                connection.release();
                if (!err) {
                    callback(rows);
                }
                else {
                    callback(null, err);
                }

            });

            connection.on('error', function (err) {
                connection.release();
                callback(null, err);
                throw err;
            });
        });
    };

    return {
        query: _query
    };
})();

module.exports = DB;

Chỉ cần sử dụng nó như vậy:

var DB = require('../dal/base.js');

DB.query("select * from tasks", null, function (data, error) {
   callback(data, error);
});

Question 6

Khi bạn hoàn tất việc kết nối, chỉ cần gọi connection.release()và kết nối sẽ trở lại chung, sẵn sàng để người khác sử dụng lại.

var mysql = require('mysql');
var pool  = mysql.createPool(...);

pool.getConnection(function(err, connection) {
  // Use the connection
  connection.query('SELECT something FROM sometable', function (error, results, fields) {
    // And done with the connection.
    connection.release();

    // Handle error after the release.
    if (error) throw error;

    // Don't use the connection here, it has been returned to the pool.
  });
});

Nếu bạn muốn đóng kết nối và xóa nó khỏi nhóm, hãy sử dụng connection.destroy()thay thế. Nhóm sẽ tạo kết nối mới vào lần tiếp theo khi cần kết nối.

Nguồn : https://github.com/mysqljs/mysql

Question 7

Sử dụng tiêu chuẩn mysql.createPool (), các kết nối được tạo một cách lười biếng bởi nhóm. Nếu bạn định cấu hình nhóm để cho phép tối đa 100 kết nối, nhưng chỉ sử dụng đồng thời 5 kết nối, thì sẽ chỉ có 5 kết nối được thực hiện. Tuy nhiên, nếu bạn định cấu hình nó cho 500 kết nối và sử dụng tất cả 500, chúng sẽ vẫn mở trong thời gian của quá trình, ngay cả khi chúng không hoạt động!

Điều này có nghĩa là nếu MySQL Server max_connections của bạn là 510, hệ thống của bạn sẽ chỉ có 10 kết nối mySQL cho đến khi MySQL Server của bạn đóng chúng (tùy thuộc vào những gì bạn đã đặt wait_timeout) hoặc ứng dụng của bạn đóng! Cách duy nhất để giải phóng chúng là đóng các kết nối theo cách thủ công thông qua phiên bản nhóm hoặc đóng nhóm.

Mô-đun mysql-connection-pool-manager đã được tạo để khắc phục sự cố này và tự động chia tỷ lệ số lượng kết nối phụ thuộc vào tải. Các kết nối không hoạt động bị đóng và các nhóm kết nối không hoạt động cuối cùng sẽ bị đóng nếu không có bất kỳ hoạt động nào.

    // Load modules
const PoolManager = require('mysql-connection-pool-manager');

// Options
const options = {
  ...example settings
}

// Initialising the instance
const mySQL = PoolManager(options);

// Accessing mySQL directly
var connection = mySQL.raw.createConnection({
  host     : 'localhost',
  user     : 'me',
  password : 'secret',
  database : 'my_db'
});

// Initialising connection
connection.connect();

// Performing query
connection.query('SELECT 1 + 1 AS solution', function (error, results, fields) {
  if (error) throw error;
  console.log('The solution is: ', results[0].solution);
});

// Ending connection
connection.end();

Tham khảo: https://www.npmjs.com/package/mysql-connection-pool-manager

Question 8

tôi luôn sử dụng connect.relase (); sau khi pool.getconnetion like

pool.getConnection(function (err, connection) {
      connection.release();
        if (!err)
        {
            console.log('*** Mysql Connection established with ', config.database, ' and connected as id ' + connection.threadId);
            //CHECKING USERNAME EXISTENCE
            email = receivedValues.email
            connection.query('SELECT * FROM users WHERE email = ?', [email],
                function (err, rows) {
                    if (!err)
                    {
                        if (rows.length == 1)
                        {
                            if (bcrypt.compareSync(req.body.password, rows[0].password))
                            {
                                var alldata = rows;
                                var userid = rows[0].id;
                                var tokendata = (receivedValues, userid);
                                var token = jwt.sign(receivedValues, config.secret, {
                                    expiresIn: 1440 * 60 * 30 // expires in 1440 minutes
                                });
                                console.log("*** Authorised User");
                                res.json({
                                    "code": 200,
                                    "status": "Success",
                                    "token": token,
                                    "userData": alldata,
                                    "message": "Authorised User!"
                                });
                                logger.info('url=', URL.url, 'Responce=', 'User Signin, username', req.body.email, 'User Id=', rows[0].id);
                                return;
                            }
                            else
                            {
                                console.log("*** Redirecting: Unauthorised User");
                                res.json({"code": 200, "status": "Fail", "message": "Unauthorised User!"});
                                logger.error('*** Redirecting: Unauthorised User');
                                return;
                            }
                        }
                        else
                        {
                            console.error("*** Redirecting: No User found with provided name");
                            res.json({
                                "code": 200,
                                "status": "Error",
                                "message": "No User found with provided name"
                            });
                            logger.error('url=', URL.url, 'No User found with provided name');
                            return;
                        }
                    }
                    else
                    {
                        console.log("*** Redirecting: Error for selecting user");
                        res.json({"code": 200, "status": "Error", "message": "Error for selecting user"});
                        logger.error('url=', URL.url, 'Error for selecting user', req.body.email);
                        return;
                    }
                });
            connection.on('error', function (err) {
                console.log('*** Redirecting: Error Creating User...');
                res.json({"code": 200, "status": "Error", "message": "Error Checking Username Duplicate"});
                return;
            });
        }
        else
        {
            Errors.Connection_Error(res);
        }
    });