Jak zapewnić połączenie z bazą danych mysql w jednym pliku w nodejs

Question

Muszę podać połączenie mysql dla modułów. Mam taki kod.

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

Ale w jaki sposób zapewniamy jednorazowe połączenie mysql dla wszystkich modułów.

Answer 1

Można utworzyć opakowanie db, a następnie go wymagać. węzeł wymaga zwracania tej samej instancji modułu za każdym razem, więc możesz wykonać połączenie i zwrócić handler'a. Od Node.js docs:

every call to require('foo') will get exactly the same object returned, if it would resolve to the same file.

Można utworzyć 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; 

Następnie w app.js, byś po prostu wymaga.

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

Takie podejście pozwala na abstrakcyjny wszelkie szczegóły połączenia, owinąć cokolwiek innego chcesz wystawiać i wymagają db całej aplikacji przy zachowaniu jednego połączenia do swoich db Dzięki jak węzeł wymaga działa :)

Answer 2

I podjął podobne podejście jak Sean3z, ale zamiast tego mam połączenie zamknięte za każdym razem, gdy robię zapytanie.

Jego sposób działa, jeśli jest wykonywany tylko w punkcie wejścia aplikacji, ale załóżmy, że masz kontrolerów, które chcesz zrobić var db = require('./db'). Nie możesz, ponieważ w przeciwnym razie za każdym razem, gdy uzyskasz dostęp do kontrolera, będziesz tworzyć nowe połączenie.

Aby tego uniknąć, uważam, że bezpieczniej jest, moim zdaniem, otwierać i zamykać połączenie za każdym razem.

tutaj jest fragment kodu.

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; 

niż można go używać w dowolnym miejscu po prostu robi jak

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

AKTUALIZACJA: config.json wygląda

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

Mam nadzieję, że to pomaga.

Answer 3

spróbować tej

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; 

Answer 4

z dokumentacji node.js, „mieć moduł wykonać kod wielokrotnie, eksportować funkcję i wywołać tę funkcję”, można użyć node.js module.export i mieć pojedynczy plik do zarządzania połączeniami db. Więcej informacji można znaleźć pod adresem Node.js documentation. Powiedzmy db.js plik będzie jak:

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

    }; 

Następnie plik gdzie masz zamiar korzystać z połączenia może być jak 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); 
    } 
}