การรวมการเชื่อมต่อ node.js + mysql

Question 1

ฉันกำลังพยายามหาวิธีจัดโครงสร้างแอปพลิเคชันเพื่อใช้ MySQL อย่างมีประสิทธิภาพมากที่สุด ฉันใช้โมดูล node-mysql เธรดอื่น ๆ ที่นี่แนะนำให้ใช้การเชื่อมต่อพูลดังนั้นฉันจึงตั้งค่าโมดูลเล็กน้อย mysql.js

var mysql = require('mysql');

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

exports.pool = pool;

ตอนนี้เมื่อใดก็ตามที่ฉันต้องการค้นหา mysql ฉันต้องการโมดูลนี้จากนั้นค้นหาฐานข้อมูล

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

แนวทางนี้ดีไหม ฉันไม่พบตัวอย่างของการใช้การเชื่อมต่อ mysql มากเกินไปนอกจากตัวอย่างที่เรียบง่ายมากซึ่งทุกอย่างเสร็จสิ้นในสคริปต์ app.js หลักดังนั้นฉันจึงไม่รู้ว่าหลักการปฏิบัติ / แนวทางปฏิบัติที่ดีที่สุดคืออะไร

ฉันควรใช้ connection.end () หลังแบบสอบถามแต่ละครั้งหรือไม่ จะเกิดอะไรขึ้นถ้าฉันลืมมันไว้ที่ไหนสักแห่ง?

วิธีการเขียนส่วนส่งออกของโมดูล mysql ของฉันใหม่เพื่อส่งคืนเฉพาะการเชื่อมต่อดังนั้นฉันจึงไม่ต้องเขียน getConnection () ทุกครั้ง

Question 2

เป็นแนวทางที่ดี

หากคุณเพียงต้องการรับการเชื่อมต่อให้เพิ่มรหัสต่อไปนี้ในโมดูลของคุณที่พูลอยู่:

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

module.exports = getConnection;

คุณยังต้องเขียน getConnection ทุกครั้ง แต่คุณสามารถบันทึกการเชื่อมต่อในโมดูลได้ในครั้งแรกที่ได้รับ

อย่าลืมยุติการเชื่อมต่อเมื่อคุณใช้งานเสร็จแล้ว:

connection.release();

Question 3

คุณควรหลีกเลี่ยงการใช้pool.getConnection()ถ้าทำได้ ถ้าจะโทรpool.getConnection()ก็ต้องโทรconnection.release()เมื่อเสร็จสิ้นโดยใช้การเชื่อมต่อ มิฉะนั้นแอปพลิเคชันของคุณจะติดค้างอยู่ตลอดเวลาเพื่อรอการเชื่อมต่อกลับไปที่พูลเมื่อคุณถึงขีด จำกัด การเชื่อมต่อ

pool.query()สำหรับคำสั่งง่ายๆที่คุณสามารถใช้ ชวเลขนี้จะโทรconnection.release()หาคุณโดยอัตโนมัติแม้จะอยู่ในสภาวะผิดพลาดก็ตาม

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

pool.getConnection()อย่างไรก็ตามในบางกรณีคุณจะต้องใช้ กรณีเหล่านี้ ได้แก่ :

สร้างแบบสอบถามหลายรายการภายในธุรกรรม
การแชร์ออบเจ็กต์ข้อมูลเช่นตารางชั่วคราวระหว่างคิวรีที่ตามมา

หากคุณต้องใช้pool.getConnection()ตรวจสอบให้แน่ใจว่าคุณโทรconnection.release()โดยใช้รูปแบบที่คล้ายกับด้านล่าง:

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

โดยส่วนตัวแล้วฉันชอบใช้Promises และuseAsync()รูปแบบมากกว่า รูปแบบนี้รวมกับasync/ awaitทำให้ลืมrelease()การเชื่อมต่อโดยไม่ตั้งใจได้ยากขึ้นมากเพราะจะเปลี่ยนการกำหนดขอบเขตคำศัพท์ของคุณเป็นการเรียกอัตโนมัติไปที่.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

คุณจะพบว่ากระดาษห่อหุ้มนี้มีประโยชน์ :)

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

Question 5

ฉันใช้การเชื่อมต่อคลาสพื้นฐานกับ 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;

เพียงแค่ใช้มัน:

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

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

Question 6

เมื่อคุณเชื่อมต่อเสร็จแล้วเพียงแค่โทรออกconnection.release()และการเชื่อมต่อจะกลับไปที่สระว่ายน้ำพร้อมให้คนอื่นใช้อีกครั้ง

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

หากคุณต้องการปิดการเชื่อมต่อและนำออกจากพูลให้ใช้connection.destroy()แทน สระว่ายน้ำจะสร้างการเชื่อมต่อใหม่ในครั้งถัดไปที่จำเป็น

ที่มา : https://github.com/mysqljs/mysql

Question 7

การใช้ mysql.createPool () มาตรฐานการเชื่อมต่อจะถูกสร้างขึ้นโดยพูลอย่างเกียจคร้าน หากคุณกำหนดค่าพูลให้อนุญาตการเชื่อมต่อสูงสุด 100 ครั้ง แต่เคยใช้ 5 ครั้งพร้อมกันเท่านั้นจะมีการเชื่อมต่อ 5 ครั้งเท่านั้น อย่างไรก็ตามหากคุณกำหนดค่าสำหรับการเชื่อมต่อ 500 ครั้งและใช้ทั้งหมด 500 รายการจะยังคงเปิดอยู่สำหรับระยะเวลาของกระบวนการแม้ว่าจะไม่ได้ใช้งานก็ตาม

ซึ่งหมายความว่าหากเซิร์ฟเวอร์ MySQL max_connections ของคุณคือ 510 ระบบของคุณจะมีการเชื่อมต่อ mySQL เพียง 10 รายการจนกว่าเซิร์ฟเวอร์ MySQL ของคุณจะปิดการเชื่อมต่อ (ขึ้นอยู่กับสิ่งที่คุณตั้งค่า wait_timeout ไว้) หรือแอปพลิเคชันของคุณปิด! วิธีเดียวที่จะทำให้พวกเขาว่างคือปิดการเชื่อมต่อด้วยตนเองผ่านอินสแตนซ์พูลหรือปิดพูล

โมดูล mysql-connection-pool-manager ถูกสร้างขึ้นเพื่อแก้ไขปัญหานี้และปรับขนาดจำนวนการเชื่อมต่อโดยอัตโนมัติโดยขึ้นอยู่กับโหลด การเชื่อมต่อที่ไม่ใช้งานถูกปิดและพูลการเชื่อมต่อที่ไม่ได้ใช้งานจะถูกปิดในที่สุดหากไม่มีกิจกรรมใด ๆ

    // 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();

อ้างอิง: https://www.npmjs.com/package/mysql-connection-pool-manager

Question 8

ฉันมักจะใช้ connection.relase (); หลังจาก pool.getconnetion เช่น

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