Cách sử dụng lại đúng cách kết nối với Mongodb trên ứng dụng và mô-đun NodeJs

Tôi đã đọc đi đọc lại và vẫn còn bối rối về cách tốt nhất để chia sẻ cùng một kết nối cơ sở dữ liệu (MongoDb) trên toàn bộ ứng dụng NodeJs. Theo tôi hiểu, kết nối sẽ được mở khi ứng dụng khởi động và sử dụng lại giữa các mô-đun. Ý tưởng hiện tại của tôi về cách tốt nhất là server.js(tệp chính nơi mọi thứ bắt đầu) kết nối với cơ sở dữ liệu và tạo biến đối tượng được chuyển đến các mô-đun. Sau khi kết nối, biến này sẽ được mã mô-đun sử dụng khi cần thiết và kết nối này vẫn mở. Ví dụ:

    var MongoClient = require('mongodb').MongoClient;
    var mongo = {}; // this is passed to modules and code

    MongoClient.connect("mongodb://localhost:27017/marankings", function(err, db) {
        if (!err) {
            console.log("We are connected");

            // these tables will be passed to modules as part of mongo object
            mongo.dbUsers = db.collection("users");
            mongo.dbDisciplines = db.collection("disciplines");

            console.log("aaa " + users.getAll()); // displays object and this can be used from inside modules

        } else
            console.log(err);
    });

    var users = new(require("./models/user"))(app, mongo);
    console.log("bbb " + users.getAll()); // not connected at the very first time so displays undefined

sau đó mô-đun khác models/usertrông giống như vậy:

Users = function(app, mongo) {

Users.prototype.addUser = function() {
    console.log("add user");
}

Users.prototype.getAll = function() {

    return "all users " + mongo.dbUsers;

    }
}

module.exports = Users;

Bây giờ tôi cảm thấy kinh khủng rằng điều này là sai, vậy có vấn đề rõ ràng nào với cách tiếp cận này không và nếu có thì làm thế nào để làm cho nó tốt hơn?

Bạn có thể tạo một mongoUtil.jsmô-đun có các chức năng để kết nối với mongo và trả về một phiên bản db mongo:

const MongoClient = require( 'mongodb' ).MongoClient;
const url = "mongodb://localhost:27017";

var _db;

module.exports = {

  connectToServer: function( callback ) {
    MongoClient.connect( url,  { useNewUrlParser: true }, function( err, client ) {
      _db  = client.db('test_db');
      return callback( err );
    } );
  },

  getDb: function() {
    return _db;
  }
};

Để sử dụng nó, bạn sẽ làm điều này trong app.js:

var mongoUtil = require( 'mongoUtil' );

mongoUtil.connectToServer( function( err, client ) {
  if (err) console.log(err);
  // start the rest of your app here
} );

Và sau đó, khi bạn cần truy cập mongo ở một nơi khác, chẳng hạn như trong một .jstệp khác , bạn có thể thực hiện điều này:

var mongoUtil = require( 'mongoUtil' );
var db = mongoUtil.getDb();

db.collection( 'users' ).find();

Lý do điều này hoạt động là trong nút, khi các mô-đun là require'd, chúng chỉ được tải / lấy nguồn một lần, vì vậy bạn sẽ chỉ kết thúc với một phiên bản của _dbvàmongoUtil.getDb() sẽ luôn trả về cùng một phiên bản đó.

Lưu ý, mã không được kiểm tra.

Có nhiều cách điều này có thể được tinh chỉnh để chấp nhận các đối tượng cấu hình ở các nơi, nhưng về tổng thể, nó tương tự như cách bạn bố trí mã của mình, mặc dù với cú pháp JS hiện đại hơn. Có thể dễ dàng được viết lại thành nguyên mẫu và gọi lại, nếu đó là yêu cầu của bạn.

mongo.js

const { MongoClient } = require('mongodb');
const config = require('./config');
const Users = require('./Users');
const conf = config.get('mongodb');

class MongoBot {
  constructor() {
    const url = `mongodb://${conf.hosts.join(',')}`;

    this.client = new MongoClient(url, conf.opts);
  }
  async init() {
    await this.client.connect();
    console.log('connected');

    this.db = this.client.db(conf.db);
    this.Users = new Users(this.db);
  }
}

module.exports = new MongoBot();

Users.js

class User {
  constructor(db) {
    this.collection = db.collection('users');
  }
  async addUser(user) {
    const newUser = await this.collection.insertOne(user);
    return newUser;
  }
}
module.exports = User;

app.js

const mongo = require('./mongo');

async function start() {
  // other app startup stuff...
  await mongo.init();
  // other app startup stuff...
}
start();

someFile.js

const { Users } = require('./mongo');

async function someFunction(userInfo) {
  const user = await Users.addUser(userInfo);
  return user;
}

Đây là cách tôi thực hiện với cú pháp hiện đại, dựa trên ví dụ của go-oleg. Của tôi được thử nghiệm và hoạt động.

Tôi đặt một số nhận xét trong mã.

./db/mongodb.js

 const MongoClient = require('mongodb').MongoClient
 const uri = 'mongodb://user:password@localhost:27017/dbName'
 let _db

 const connectDB = async (callback) => {
     try {
         MongoClient.connect(uri, (err, db) => {
             _db = db
             return callback(err)
         })
     } catch (e) {
         throw e
     }
 }

 const getDB = () => _db

 const disconnectDB = () => _db.close()

 module.exports = { connectDB, getDB, disconnectDB }

./index.js

 // Load MongoDB utils
 const MongoDB = require('./db/mongodb')
 // Load queries & mutations
 const Users = require('./users')

 // Improve debugging
 process.on('unhandledRejection', (reason, p) => {
     console.log('Unhandled Rejection at:', p, 'reason:', reason)
 })

 const seedUser = {
     name: 'Bob Alice',
     email: 'test@dev.null',
     bonusSetting: true
 }

 // Connect to MongoDB and put server instantiation code inside
 // because we start the connection first
 MongoDB.connectDB(async (err) => {
     if (err) throw err
     // Load db & collections
     const db = MongoDB.getDB()
     const users = db.collection('users')

     try {
         // Run some sample operations
         // and pass users collection into models
         const newUser = await Users.createUser(users, seedUser)
         const listUsers = await Users.getUsers(users)
         const findUser = await Users.findUserById(users, newUser._id)

         console.log('CREATE USER')
         console.log(newUser)
         console.log('GET ALL USERS')
         console.log(listUsers)
         console.log('FIND USER')
         console.log(findUser)
     } catch (e) {
         throw e
     }

     const desired = true
     if (desired) {
         // Use disconnectDB for clean driver disconnect
         MongoDB.disconnectDB()
         process.exit(0)
     }
     // Server code anywhere above here inside connectDB()
 })

./users/index.js

 const ObjectID = require('mongodb').ObjectID

 // Notice how the users collection is passed into the models
 const createUser = async (users, user) => {
     try {
         const results = await users.insertOne(user)
         return results.ops[0]
     } catch (e) {
         throw e
     }
 }

 const getUsers = async (users) => {
     try {
         const results = await users.find().toArray()
         return results
     } catch (e) {
         throw e
     }
 }

 const findUserById = async (users, id) => {
     try {
         if (!ObjectID.isValid(id)) throw 'Invalid MongoDB ID.'
         const results = await users.findOne(ObjectID(id))
         return results
     } catch (e) {
         throw e
     }
 }

 // Export garbage as methods on the Users object
 module.exports = { createUser, getUsers, findUserById }

Nếu bạn đang sử dụng Express, thì bạn có thể sử dụng mô-đun express-mongo-db cho phép bạn nhận kết nối db trong đối tượng yêu cầu.

Tải về

npm install --save express-mongo-db

server.js

var app = require('express')();

var expressMongoDb = require('express-mongo-db');
app.use(expressMongoDb('mongodb://localhost/test'));

route / users.js

app.get('/', function (req, res, next) {
    req.db // => Db object
});

go-oleg về cơ bản là đúng, nhưng trong những ngày này, bạn (có thể) không muốn sử dụng chính "mongodb", thay vào đó sử dụng một số khuôn khổ, sẽ làm rất nhiều "công việc bẩn thỉu" cho bạn.

Ví dụ, cầy mangut là một trong những loài phổ biến nhất. Đây là những gì chúng tôi có trong server.jstệp ban đầu của mình :

const mongoose = require('mongoose');
const options = {server: {socketOptions: {keepAlive: 1}}};
mongoose.connect(config.db, options);

Đây là mọi thứ cần thiết để thiết lập nó. Bây giờ sử dụng cái này ở bất kỳ đâu trong mã của bạn

const mongoose = require('mongoose');

Và bạn nhận được phiên bản mà bạn đã thiết lập mongoose.connect

Khởi tạo kết nối như một lời hứa:

const MongoClient = require('mongodb').MongoClient
const uri = 'mongodb://...'
const client = new MongoClient(uri)
const connection = client.connect() // initialized connection

Và sau đó gọi kết nối bất cứ khi nào bạn muốn bạn thực hiện một hành động trên cơ sở dữ liệu:

    // if I want to insert into the database...
    const connect = connection
    connect.then(() => {
        const doc = { id: 3 }
        const db = client.db('database_name')
        const coll = db.collection('collection_name')
        coll.insertOne(doc, (err, result) => {
            if(err) throw err
        })
    })

Một giải pháp đã được thử nghiệm dựa trên câu trả lời được chấp nhận:

mongodbutil.js:

var MongoClient = require( 'mongodb' ).MongoClient;
var _db;
module.exports = {
  connectToServer: function( callback ) {
    MongoClient.connect( "<connection string>", function( err, client ) {
      _db = client.db("<collection name>");
      return callback( err );
    } );
  },
  getDb: function() {
    return _db;
  }
};

app.js:

var createError = require('http-errors');
var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
var logger = require('morgan');
var app = express();
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.use(logger('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

var mongodbutil = require( './mongodbutil' );
mongodbutil.connectToServer( function( err ) {
  //app goes online once this callback occurs
  var indexRouter = require('./routes/index');
  var usersRouter = require('./routes/users');
  var companiesRouter = require('./routes/companies');
  var activitiesRouter = require('./routes/activities');
  var registerRouter = require('./routes/register');  
  app.use('/', indexRouter);
  app.use('/users', usersRouter);
  app.use('/companies', companiesRouter);
  app.use('/activities', activitiesRouter);
  app.use('/register', registerRouter);  
  // catch 404 and forward to error handler
  app.use(function(req, res, next) {
    next(createError(404));
  });
  // error handler
  app.use(function(err, req, res, next) {
    res.locals.message = err.message;
    res.locals.error = req.app.get('env') === 'development' ? err : {};
    res.status(err.status || 500);
    res.render('error');
  });
  //end of calback
});

module.exports = app;

activity.js - một tuyến đường:

var express = require('express');
var router = express.Router();
var mongodbutil = require( '../mongodbutil' );
var db = mongodbutil.getDb();

router.get('/', (req, res, next) => {  
    db.collection('activities').find().toArray((err, results) => {
        if (err) return console.log(err)
            res.render('activities', {activities: results, title: "Activities"})
    });
});

router.post('/', (req, res) => {
  db.collection('activities').save(req.body, (err, result) => {
    if (err) return console.log(err)
    res.redirect('/activities')
  })
});

module.exports = router;

Đây là thiết lập của tôi vào năm 2020:

./utils/database.js

const { MongoClient } = require('mongodb');

class Mongo {
    constructor () {
        this.client = new MongoClient("mongodb://127.0.0.1:27017/my-app", {
            useNewUrlParser: true,
            useUnifiedTopology: true
        });
    }

    async main () {
        await this.client.connect();
        console.log('Connected to MongoDB');

        this.db = this.client.db();
    }
}

module.exports = new Mongo();

/app.js

const mongo = require('./utils/database');
const express = require('express');

const app = express();

const boot = async () => {
    await mongo.main();
    app.listen(3000);
};

boot();

chúng ta có thể tạo một tệp dbconnection như dbconnection.js

const MongoClient = require('mongodb').MongoClient
const mongo_url = process.env.MONGO_URL;

    module.exports = {
        connect: async function(callback) {
            var connection;
            await new Promise((resolve, reject) => {
                MongoClient.connect(mongo_url, {
                    useNewUrlParser: true
                }, (err, database) => {
                    if (err)
                        reject();
                    else {
                        connection = database;
                        resolve();
                    }
                });
            });
            return connection;
        }

    };

và sau đó sử dụng tệp này trong ứng dụng của bạn như

var connection = require('../dbconnection');

và sau đó sử dụng như thế này bên trong hàm không đồng bộ của bạn

db  = await connection.connect();

hy vọng điều này sẽ hiệu quả

Tôi hơi muộn cho việc này, nhưng tôi cũng sẽ thêm giải pháp của mình. Đó là một cách tiếp cận không có nhiều so với các câu trả lời ở đây.

Dù sao nếu bạn đang sử dụng MongoDB phiên bản 4.0 và Node.js 3.0 (hoặc các phiên bản cao hơn), bạn có thể sử dụng isConnected()chức năng từ MongoClient.

const MongoClient = require('mongodb').MongoClient;
const uri = "<your connection url>";
const client = new MongoClient(uri, { useNewUrlParser: true });

if (client.isConnected()) {
  execute();
} else {
  client.connect().then(function () {
    execute();
  });
}

function execute() {
    // Do anything here
    // Ex: client.db("mydb").collection("mycol");
}

Điều này làm việc tốt cho tôi. Hy vọng nó giúp.

Tôi đến bữa tiệc muộn, nhưng hy vọng câu trả lời này sẽ giúp ích cho ai đó, đây là mã chức năng:

db.js

const MongoClient = require("mongodb").MongoClient
const urlMongo = "mongodb://localhost:27017"

var db;

function connectToServer( callback ) {
    MongoClient.connect(urlMongo,  { useUnifiedTopology: true , useNewUrlParser: true }, function( err, client ) {
        db  = client.db('auth');
        return callback( err );
    })
}

function getDb() {
    return db
}

module.exports = {connectToServer, getDb}

Chúng tôi xuất một hàm để kết nối với mongo và một hàm khác để lấy mẫu của kết nối.

app.js

const express = require('express')
const app = express()

const mongo = require('./db.js');

mongo.connectToServer( function( err) {
  if (err) console.log(err);
  const auth = require('./modulos')

  app.post('/login', (req, res) => { auth.login(req, res)})
  app.listen(3000, function () { console.log('Corriendo en puerto 3000')})

});

Chúng ta phải thực hiện yêu cầu của mô-đun auth sau khi chúng ta khởi tạo kết nối, nếu không hàm getDb sẽ trả về không xác định.

module.js

const db = require('../db.js').getDb()
const usuariosCollection = db.collection('usuarios')

function login(req, res){
    usuariosCollection.find({ 'username': 'Fran' }).toArray(function (err, doc) {
        ...
    })
}

Vì điều này được gắn thẻ với Express, tôi nghĩ rằng tôi sẽ đề cập rằng Express có một tính năng tích hợp để chia sẻ dữ liệu giữa các tuyến đường. Có một đối tượng được gọi là app.locals. Chúng tôi có thể đính kèm các thuộc tính vào nó và truy cập nó từ bên trong các tuyến đường của chúng tôi. Bạn chỉ cần khởi tạo kết nối mongo của mình trong tệp app.js.

var app = express();

MongoClient.connect('mongodb://localhost:27017/')
.then(client =>{
  const db = client.db('your-db');
  const collection = db.collection('your-collection');
  app.locals.collection = collection;
});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              // view engine setup
app.set('views', path.join(__dirname, 'views'));

Kết nối cơ sở dữ liệu này hiện có thể được truy cập trong các tuyến của bạn như bên dưới mà không cần tạo và yêu cầu các mô-đun bổ sung.

app.get('/', (req, res) => {
  const collection = req.app.locals.collection;
  collection.find({}).toArray()
  .then(response => res.status(200).json(response))
  .catch(error => console.error(error));
});

Phương pháp này đảm bảo rằng bạn có một kết nối cơ sở dữ liệu mở trong suốt thời gian của ứng dụng trừ khi bạn chọn đóng nó bất kỳ lúc nào. Nó dễ dàng truy cập với req.app.locals.your-collectionvà không yêu cầu mô-đun bổ sung.

Nếu bạn chọn sử dụng mongoose trong ứng dụng của mình, hãy chỉnh sửa tệp app.js của bạn bằng đoạn mã sau

app.js

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/Your_Data_Base_Name', {useNewUrlParser:true})
  .then((res) => {
    console.log(' ########### Connected to mongDB ###########');
  })
  .catch((err) => {
    console.log('Error in connecting to mongoDb' + err);
  });`

Bước tiếp theo: Xác định Mô hình cho ứng dụng của bạn yêu cầu chúng và thực hiện thao tác CRUD trực tiếp chẳng hạn

blogSchema.js

 const mongoose = require('mongoose');
 const Schema = mongoose.Schema;
 const blogSchema = new Schema({
     _id : mongoose.Schema.Types.ObjectId,
     title : {
        type : 'String',
        unique : true,
        required : true       
    },
    description : String,
        comments : [{type : mongoose.Schema.Types.ObjectId, ref: 'Comment'}]
 });
 module.exports = mongoose.model('Blog', blogSchema);

Cách sử dụng createBlog.js

const Blog = require('../models/blogSchema');
exports.createBlog = (req, res, next) => {
const blog = new Blog({
  _id : new mongoose.Types.ObjectId,
  title : req.body.title,
  description : req.body.description,
});
blog.save((err, blog) => {
  if(err){
    console.log('Server Error save fun failed');
    res.status(500).json({
      msg : "Error occured on server side",
      err : err
    })
  }else{
    //do something....
  }

Bạn không cần phải kết nối với mogoDB luôn ...

var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost:27017/';
var Pro1;

module.exports = {
    DBConnection:async function()
    {
        Pro1 = new Promise(async function(resolve,reject){
            MongoClient.connect(url, { useNewUrlParser: true },function(err, db) {
                if (err) throw err;
                resolve(db);
            });        
        });
    },
    getDB:async function(Blockchain , Context)
    {
        bc = Blockchain;
        contx = Context;
        Pro1.then(function(_db)
        {
            var dbo = _db.db('dbname');
            dbo.collection('collectionname').find().limit(1).skip(0).toArray(function(err,result) {
                if (err) throw err;
                console.log(result);
            });
        });
    },
    closeDB:async function()
    {
        Pro1.then(function(_db){
            _db.close();
        });
    }
};

const express = require('express')
const server = express()
const mongoClient = require('./MongoDB.js').client
const port = 3000
;(async () => {
    await mongoClient.connect()
    server.listen(port, () => console.log(`Server is listening on port ${port}!`))
})().catch(console.error)

Tôi thấy điều này hoạt động tốt :)

mongoUtil.ts

import { MongoClient } from 'mongodb';
const uri =
  'MONGOSTRING';

let connPoolPromise: any = null;

const mongoPoolPromise = () => {
  if (connPoolPromise) return connPoolPromise;

  connPoolPromise = new Promise((resolve, reject) => {
    const conn = new MongoClient(uri, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });

    if (conn.isConnected()) {
      return resolve(conn);
    } else {
      conn
        .connect()
        .then(() => {
          return resolve(conn.db('DATABASENAME'));
        })
        .catch(err => {
          console.log(err);
          reject(err);
        });
    }
  });

  return connPoolPromise;
};

export = {
  mongoPoolPromise,
};

anyFile.ts

const { mongoPoolPromise } = require('./mongoUtil');

async function getProducts() {
  const db = await mongoPoolPromise();
  const data = await db
    .collection('myCollection')
    .find({})
    .toArray();
  console.log(data);
  return data;
}

export { getProducts };