วิธีการนำการเชื่อมต่อกับ Mongodb กลับมาใช้ใหม่อย่างถูกต้องผ่านแอปพลิเคชันและโมดูล NodeJs

ฉันอ่านและอ่านและยังสับสนว่าวิธีใดดีที่สุดในการแชร์การเชื่อมต่อฐานข้อมูลเดียวกัน (MongoDb) ในแอป NodeJs ทั้งหมด ตามที่ฉันเข้าใจควรเปิดการเชื่อมต่อเมื่อแอปเริ่มต้นและใช้ซ้ำระหว่างโมดูล แนวคิดปัจจุบันของฉันเกี่ยวกับวิธีที่ดีที่สุดคือserver.js(ไฟล์หลักที่ทุกอย่างเริ่มต้น) เชื่อมต่อกับฐานข้อมูลและสร้างตัวแปรออบเจ็กต์ที่ส่งผ่านไปยังโมดูล เมื่อเชื่อมต่อแล้วตัวแปรนี้จะถูกใช้โดยรหัสโมดูลตามความจำเป็นและการเชื่อมต่อนี้ยังคงเปิดอยู่ เช่น:

    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

จากนั้นโมดูลอื่นจะmodels/userมีลักษณะดังนี้:

Users = function(app, mongo) {

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

Users.prototype.getAll = function() {

    return "all users " + mongo.dbUsers;

    }
}

module.exports = Users;

ตอนนี้ฉันรู้สึกแย่มากว่านี่ไม่ถูกต้องดังนั้นมีปัญหาที่ชัดเจนเกี่ยวกับแนวทางนี้หรือไม่และถ้าเป็นเช่นนั้นจะทำให้ดีขึ้นได้อย่างไร

คุณสามารถสร้างmongoUtil.jsโมดูลที่มีฟังก์ชันทั้งเชื่อมต่อกับ mongo และส่งคืนอินสแตนซ์ mongo db:

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

ในการใช้งานคุณจะต้องทำสิ่งนี้ในapp.js:

var mongoUtil = require( 'mongoUtil' );

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

จากนั้นเมื่อคุณต้องการเข้าถึง mongo ที่อื่นเช่นใน.jsไฟล์อื่นคุณสามารถทำได้:

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

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

เหตุผลที่ใช้งานได้คือในโหนดเมื่อโมดูลเป็นrequire'd พวกมันจะถูกโหลด / แหล่งที่มาเพียงครั้งเดียวดังนั้นคุณจะได้รับอินสแตนซ์เพียงครั้งเดียว_dbและmongoUtil.getDb()จะส่งคืนอินสแตนซ์เดียวกันเสมอ

หมายเหตุไม่ได้ทดสอบโค้ด

มีหลายวิธีที่สามารถปรับแต่งเพื่อยอมรับออบเจ็กต์การกำหนดค่าในสถานที่ต่างๆได้ แต่โดยรวมแล้วจะคล้ายกับการวางโค้ดของคุณแม้ว่าจะมีไวยากรณ์ JS ที่ทันสมัยกว่าก็ตาม สามารถเขียนใหม่เป็นต้นแบบและการเรียกกลับได้อย่างง่ายดายหากเป็นความต้องการของคุณ

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

นี่คือวิธีที่ฉันใช้กับไวยากรณ์ร่วมสมัยตามตัวอย่างของ go-oleg เหมืองได้รับการทดสอบและใช้งานได้

ฉันใส่ความคิดเห็นไว้ในโค้ด

./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 }

หากคุณใช้ Express คุณสามารถใช้โมดูลexpress-mongo-dbที่ช่วยให้คุณสามารถรับการเชื่อมต่อ db ในออบเจ็กต์คำขอ

ติดตั้ง

npm install --save express-mongo-db

server.js

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

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

เส้นทาง / users.js

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

go-oleg เป็นสิ่งที่ถูกต้อง แต่ในสมัยนี้คุณ (อาจ) ไม่ต้องการใช้ "mongodb" แต่ใช้กรอบงานบางอย่างซึ่งจะทำให้ "งานสกปรก" มากมายสำหรับคุณ

ตัวอย่างเช่นพังพอนเป็นหนึ่งในพังพอนที่พบมากที่สุด นี่คือสิ่งที่เรามีในserver.jsไฟล์เริ่มต้นของเรา:

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

นี่คือทุกสิ่งที่จำเป็นในการตั้งค่า ตอนนี้ใช้สิ่งนี้ได้ทุกที่ในรหัสของคุณ

const mongoose = require('mongoose');

และคุณจะได้รับอินสแตนซ์ที่คุณตั้งค่าไว้ mongoose.connect

เริ่มต้นการเชื่อมต่อตามคำสัญญา:

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

จากนั้นเรียกการเชื่อมต่อเมื่อใดก็ตามที่คุณต้องการให้ดำเนินการกับฐานข้อมูล:

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

โซลูชันที่ผ่านการทดสอบตามคำตอบที่ยอมรับ:

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 - เส้นทาง:

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;

นี่คือการตั้งค่าของฉันในปี 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();

เราสามารถสร้างไฟล์ dbconnection เช่น 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;
        }

    };

จากนั้นใช้ไฟล์นี้ในแอปของคุณเช่น

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

จากนั้นใช้สิ่งนี้ในฟังก์ชัน async ของคุณ

db  = await connection.connect();

หวังว่าจะได้ผล

ฉันช้าไปหน่อยสำหรับเรื่องนี้ แต่ฉันจะเพิ่มวิธีแก้ปัญหาด้วย มันเป็นวิธีที่ไม่มีอะไรมากนักเมื่อเทียบกับคำตอบที่นี่

อย่างไรก็ตามหากคุณใช้ MongoDB เวอร์ชัน 4.0 และ Node.js 3.0 (หรือเวอร์ชันที่สูงกว่า) คุณสามารถใช้isConnected()ฟังก์ชันจากไฟล์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");
}

สิ่งนี้ใช้ได้ดีสำหรับฉัน หวังว่าจะช่วยได้

ฉันมางานปาร์ตี้ช้า แต่หวังว่าคำตอบนี้จะช่วยใครบางคนนี่เป็นรหัสที่ใช้งานได้:

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}

เราส่งออกฟังก์ชันหนึ่งเพื่อเชื่อมต่อกับ mongo และอีกฟังก์ชันหนึ่งเพื่อรับอินสแตนซ์ของการเชื่อมต่อ

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

});

เราต้องดำเนินการตามความต้องการของโมดูลการตรวจสอบสิทธิ์หลังจากที่เราเริ่มต้นการเชื่อมต่อมิฉะนั้นฟังก์ชัน getDb จะกลับมาไม่ได้กำหนดไว้

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

เนื่องจากมีการติดแท็ก Express ฉันคิดว่าฉันจะพูดถึงว่า Express มีคุณลักษณะในตัวเพื่อแชร์ข้อมูลระหว่างเส้นทาง มีวัตถุที่เรียกว่า app.locals เราสามารถแนบคุณสมบัติและเข้าถึงได้จากภายในเส้นทางของเรา คุณเพียงแค่สร้างอินสแตนซ์การเชื่อมต่อ mongo ในไฟล์ 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'));

ขณะนี้การเชื่อมต่อฐานข้อมูลนี้สามารถเข้าถึงได้ภายในเส้นทางของคุณดังต่อไปนี้โดยไม่จำเป็นต้องสร้างและต้องใช้โมดูลเพิ่มเติม

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

วิธีนี้ช่วยให้มั่นใจได้ว่าคุณเปิดการเชื่อมต่อฐานข้อมูลตลอดระยะเวลาของแอปเว้นแต่คุณจะเลือกปิดเมื่อใดก็ได้ เข้าถึงได้ง่ายด้วยreq.app.locals.your-collectionและไม่ต้องใช้โมดูลเพิ่มเติม

หากคุณเลือกใช้พังพอนในแอปพลิเคชันของคุณให้แก้ไขไฟล์ app.js ของคุณด้วยข้อมูลโค้ดต่อไปนี้

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

ขั้นตอนต่อไป: กำหนดรุ่นสำหรับแอปพลิเคชันของคุณต้องการและดำเนินการ CRUD โดยตรงเช่น

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

การใช้งาน 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....
  }

คุณไม่จำเป็นต้องเชื่อมต่อกับ mogoDB เสมอไป ....

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)

ฉันพบว่ามันใช้งานได้ดี :)

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

จากคำตอบที่ยอมรับฉันใช้วิธีง่ายๆ แต่ใช้สิ่งนี้เฉพาะในกรณีที่คุณต้องการใช้dbฟังก์ชันภายในซึ่งจะถูกดำเนินการในภายหลัง ตัวอย่างเช่นในฟังก์ชันเส้นทางด่วนเป็นวิธีที่ง่ายที่สุดที่คุณสามารถทำได้

mongo.js

const MongoClient = require("mongodb").MongoClient

var db

const connectDb = (callback) => {
    if (db) return callback()
    MongoClient.connect( uri, {ops}, 
        (err, database) => {
            if (err) return console.log(err)
            db = database.db("dbName") 
            console.log("Database Connected")
            callback()
        }
    )
}

const getDb = (collectionToGet) => {
    return db.collection(collectionToGet)
}

module.exports = {
    connectDb,
    getDb,
}

ตอนนี้ในไฟล์อื่น ๆ ที่คุณต้องการวัตถุ db

user.js

const { connectDb, getDb } = require('mongo.js')

var db // store db object in this object
connectDb(() => ( db = getDb("user") ))

app.get('/', (req, res) => {
    // do something with req 
    db.insert({})
    // do something with res
}