web-dev-qa-db-fra.com

Comment fournir une connexion à une base de données mysql dans un seul fichier dans nodejs

J'ai besoin de fournir la connexion mysql pour les modules. J'ai un code comme celui-ci.

var express = require('express'),
app = express(),
server = require('http').createServer(app);

var mysql      = require('mysql');
var connection = mysql.createConnection({
    Host     : '127.0.0.1',
    user     : 'root',
    password : '',
    database    : 'chat'
});

connection.connect(function(err) {
    if (err) {
        console.error('error connecting: ' + err.stack);
        return;
    }
});

app.get('/save', function(req,res){
    var post  = {from:'me', to:'you', msg:'hi'};
    var query = connection.query('INSERT INTO messages SET ?', post, function(err, result) {
        if (err) throw err;
    });
});

server.listen(3000);

Mais comment nous fournissons une connexion mysql unique pour tous les modules.

mysqlnode.jsexpressnode-modules
42
user3836476

Vous pouvez créer un wrapper de base de données puis en avoir besoin. node's require renvoie la même instance d'un module à chaque fois, vous pouvez ainsi établir votre connexion et renvoyer un gestionnaire. À partir de la documentation Node.js :

chaque appel à demander ('foo') obtiendra exactement le même objet renvoyé, s'il est résolu dans le même fichier.

Vous pouvez créer db.js:

var mysql = require('mysql');
var connection = mysql.createConnection({
    Host     : '127.0.0.1',
    user     : 'root',
    password : '',
    database : 'chat'
});

connection.connect(function(err) {
    if (err) throw err;
});

module.exports = connection;

Puis dans votre app.js, vous en auriez simplement besoin.

var express = require('express');
var app = express();
var db = require('./db');

app.get('/save',function(req,res){
    var post  = {from:'me', to:'you', msg:'hi'};
    db.query('INSERT INTO messages SET ?', post, function(err, result) {
      if (err) throw err;
    });
});

server.listen(3000);

Cette approche vous permet d’abstraire les détails de connexion, d’envelopper tout ce que vous voulez exposer et d’exiger db dans votre application tout en maintenant une connexion à votre base de données, grâce au fonctionnement nécessaire des nœuds :)

127
Sean3z

J'ai adopté une approche similaire à celle de Sean3z, mais au lieu de cela, la connexion est fermée à chaque fois que je pose une requête.

Sa manière de fonctionner ne fonctionne que si elle est exécutée uniquement sur le point d’entrée de votre application, mais supposons que vous ayez des contrôleurs pour lesquels vous souhaitez effectuer une var db = require('./db'). Vous ne pouvez pas, car sinon, chaque fois que vous accéderez à ce contrôleur, vous créerez une nouvelle connexion.

Pour éviter cela, je pense qu’il est plus sûr, à mon avis, d’ouvrir et de fermer la connexion à chaque fois.

voici un extrait de mon code.

mysq_query.js

// Dependencies
var mysql   = require('mysql'),
    config  = require("../config");

/*
 * @sqlConnection
 * Creates the connection, makes the query and close it to avoid concurrency conflicts.
 */
var sqlConnection = function sqlConnection(sql, values, next) {

    // It means that the values hasnt been passed
    if (arguments.length === 2) {
        next = values;
        values = null;
    }

    var connection = mysql.createConnection(config.db);
    connection.connect(function(err) {
        if (err !== null) {
            console.log("[MYSQL] Error connecting to mysql:" + err+'\n');
        }
    });

    connection.query(sql, values, function(err) {

        connection.end(); // close the connection

        if (err) {
            throw err;
        }

        // Execute the callback
        next.apply(this, arguments);
    });
}

module.exports = sqlConnection;

Que vous puissiez l'utiliser n'importe où, simplement comme

var mysql_query = require('path/to/your/mysql_query');
mysql_query('SELECT * from your_table where ?', {id: '1'}, function(err, rows)   {
    console.log(rows);
});

PDATED: config.json ressemble à

{
        "db": {
        "user"     : "USERNAME",
        "password" : "PASSWORD",
        "database" : "DATABASE_NAME",
        "socketPath": "/tmp/mysql.sock"
    }
}

J'espère que cela t'aides.

12
Rafael

Je pense que vous devriez utiliser un pool de connexion au lieu de partager une seule connexion. Un pool de connexions fournirait de bien meilleures performances, comme vous pouvez le vérifier ici .

Comme indiqué dans la bibliothèque documentation , cela se produit car le protocole MySQL est séquentiel (cela signifie que vous avez besoin de plusieurs connexions pour exécuter des requêtes en parallèle).

Documents du pool de connexions

1
Thiago Bustamante
var mysql = require('mysql');

var pool  = mysql.createPool({
    Host     : 'yourip',
    port    : 'yourport',
    user     : 'dbusername',
    password : 'dbpwd',
    database : 'database schema name',
    dateStrings: true,
    multipleStatements: true
});


// TODO - if any pool issues need to try this link for connection management
// https://stackoverflow.com/questions/18496540/node-js-mysql-connection-pooling

module.exports = function(qry, qrytype, msg, callback) {

if(qrytype != 'S') {
    console.log(qry);
}

pool.getConnection(function(err, connection) {
    if(err) {
        if(connection)
            connection.release();
        throw err;
    } 

    // Use the connection
    connection.query(qry, function (err, results, fields) {
        connection.release();

        if(err) {
            callback('E#connection.query-Error occurred.#'+ err.sqlMessage);    
            return;         
        }

        if(qrytype==='S') {
            //for Select statement
            // setTimeout(function() {
                callback(results);      
            // }, 500);
        } else if(qrytype==='N'){
            let resarr = results[results.length-1];
            let newid= '';
            if(resarr.length)               
                newid = resarr[0]['@eid'];
            callback(msg + newid);
        } else if(qrytype==='U'){
            //let ret = 'I#' + entity + ' updated#Updated rows count: ' + results[1].changedRows;
            callback(msg);                      
        } else if(qrytype==='D'){
            //let resarr = results[1].affectedRows;
            callback(msg);
        }
    });

    connection.on('error', function (err) {
        connection.release();
        callback('E#connection.on-Error occurred.#'+ err.sqlMessage);   
        return;         
    });
});

}

1
Surendra Kumar Laggisetty

essaye ça

var express = require('express');

var mysql     =    require('mysql');

var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');

var routes = require('./routes/index');
var users = require('./routes/users');

var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);
app.use('/users', users);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handlers

// development error handler
// will print stacktrace
console.log(app);
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
      message: err.message,
      error: err
    });
  });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
    error: {}
  });
});

var con = mysql.createConnection({
  Host: "localhost",
  user: "root",
  password: "admin123",
  database: "sitepoint"
});

con.connect(function(err){
  if(err){
    console.log('Error connecting to Db');
    return;
  }
  console.log('Connection established');
});



module.exports = app;
1
Pankaj katiyar

Dans la documentation de node.js, "Pour qu'un module exécute le code plusieurs fois, exporte une fonction et appelle cette fonction", vous pouvez utiliser le fichier node.js module.export et disposer d'un fichier unique pour gérer les connexions à la base de données. plus sur documentation Node.js . Disons que le fichier db.js ressemble à ceci:

    const mysql = require('mysql');

    var connection;

    module.exports = {

    dbConnection: function () {

        connection = mysql.createConnection({
            Host: "127.0.0.1",
            user: "Your_user",
            password: "Your_password",
            database: 'Your_bd'
        });
        connection.connect();
        return connection;
    }

    };

Ensuite, le fichier où vous utiliserez la connexion pourrait ressembler à useDb.js:

const dbConnection = require('./db');

var connection;

function callDb() {

    try {

        connection = dbConnectionManager.dbConnection();

        connection.query('SELECT 1 + 1 AS solution', function (error, results, fields) {
            if (!error) {

                let response = "The solution is: " + results[0].solution;
                console.log(response);

            } else {
                console.log(error);
            }
        });
        connection.end();


    } catch (err) {
        console.log(err);
    }
}
0
Towerss