NodeJs uygulaması ve modülleri genelinde Mongodb bağlantısı nasıl düzgün şekilde yeniden kullanılır?

NodeJs uygulamasının tamamında aynı veritabanı (MongoDb) bağlantısını paylaşmanın en iyi yolunun ne olduğu konusunda okuyup okuyorum ve hala kafam karışık. Anladığım kadarıyla uygulama başladığında ve modüller arasında yeniden kullanıldığında bağlantı açık olmalı. En iyi yol hakkındaki mevcut fikrim ( server.jsher şeyin başladığı ana dosya) veritabanına bağlanır ve modüllere aktarılan nesne değişkeni oluşturur. Bağlandıktan sonra bu değişken modül kodu tarafından gerektiği gibi kullanılacaktır ve bu bağlantı açık kalacaktır. Örneğin:

    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

sonra başka bir modül models/userşuna benzer:

Users = function(app, mongo) {

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

Users.prototype.getAll = function() {

    return "all users " + mongo.dbUsers;

    }
}

module.exports = Users;

Şimdi bunun yanlış olduğuna dair korkunç bir his var, bu yüzden bu yaklaşımla ilgili bariz sorunlar var mı ve eğer öyleyse nasıl daha iyi hale getirebilirim?

mongoUtil.jsHem mongo'ya bağlanmak hem de bir mongo db örneği döndürmek için işlevlere sahip bir modül oluşturabilirsiniz :

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

Kullanmak için şunu yaparsınız app.js:

var mongoUtil = require( 'mongoUtil' );

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

Ve sonra mongo'ya başka bir .jsdosyada olduğu gibi başka bir yerden erişmeniz gerektiğinde , bunu yapabilirsiniz:

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

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

Bunun işe yaramasının nedeni, düğümde modüller require'd olduğunda, bunlar yalnızca bir kez yüklenir / kaynaklanır, böylece yalnızca bir örneğiyle sonlanırsınız _dbve mongoUtil.getDb()her zaman aynı örneği döndürürsünüz.

Not, kod test edilmemiştir.

Yerlerde yapılandırma nesnelerini kabul etmek için bunun birçok yolu vardır, ancak genel olarak, daha modern JS sözdizimi olsa da, kodunuzu nasıl yerleştirdiğinize benzer. Gereksiniminiz buysa, prototiplere ve geri aramalara kolayca yeniden yazılabilir.

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'in örneğine göre bunu çağdaş sözdizimiyle nasıl yapıyorum. Benimki test edildi ve çalışıyor.

Koda bazı yorumlar ekledim.

./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 kullanıyorsanız, istek nesnesinde db bağlantısı almanızı sağlayan express-mongo-db modülünü kullanabilirsiniz .

Yüklemek

npm install --save express-mongo-db

server.js

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

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

rotalar / users.js

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

go-oleg temelde haklı, ancak bu günlerde (muhtemelen) "mongodb" u kullanmak istemiyorsunuz, bunun yerine sizin için çok fazla "kirli iş" yapacak bir çerçeve kullanıyorsunuz.

Örneğin firavun faresi en yaygın olanlardan biridir. İlk server.jsdosyamızda bu var:

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

Kurmak için gereken her şey budur. Şimdi bunu kodunuzun herhangi bir yerinde kullanın

const mongoose = require('mongoose');

Ve kurduğunuz örneği alırsınız mongoose.connect

Bağlantıyı bir söz olarak başlatın:

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

Ardından, veritabanında bir eylem gerçekleştirmeyi dilediğinizde bağlantıyı arayın:

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

Kabul edilen cevaba dayalı test edilmiş bir çözüm:

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 - bir rota:

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;

İşte 2020'deki kurulumum:

./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.js gibi bir dbconnection dosyası oluşturabiliriz

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

    };

ve sonra bu dosyayı uygulamanızda şu şekilde kullanın:

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

ve sonra eşzamansız işlevinizin içinde bu şekilde kullanın

db  = await connection.connect();

umarım bu işe yarar

Bunun için biraz geç kaldım ama çözümümü de ekleyeceğim. Buradaki cevaplara kıyasla çok daha basit bir yaklaşım.

Eğer MongoDB sürüm 4.0 ve node.js 3.0 (veya daha yüksek sürümleri) kullanıyorsanız Neyse eğer kullanabilirsiniz isConnected()gelen işlevi 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");
}

Bu benim için iyi çalıştı. Umarım yardımcı olur.

Partiye geç kaldım ama umarım bu cevap birine yardımcı olur, bu işlevsel bir koddur:

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'ya bağlanmak için bir işlevi ve bağlantının örneğini almak için başka bir işlevi dışa aktarıyoruz.

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

});

Auth modülünün ihtiyacını bağlantıyı başlattıktan sonra yapmalıyız, aksi takdirde getDb işlevi undefined döndürür.

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

Bu Express ile etiketlendiğinden, Express'in rotalar arasında veri paylaşmak için yerleşik bir özelliğe sahip olduğundan bahsedeceğimi düşündüm. App.locals adında bir nesne var. Ona mülkler ekleyebilir ve rotalarımızın içinden erişebiliriz. Sadece mongo bağlantınızı app.js dosyanızda başlatırsınız.

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

Bu veritabanı bağlantısına artık ek modüller oluşturmaya ve gerek duymadan aşağıdaki gibi rotalarınızdan erişilebilir.

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

Bu yöntem, herhangi bir zamanda kapatmayı seçmediğiniz sürece uygulamanızın süresi boyunca açık bir veritabanı bağlantınız olmasını sağlar. req.app.locals.your-collectionEk modüllerle kolayca erişilebilir ve ek modüller gerektirmez.

Uygulamanızda mongoose kullanmayı tercih ederseniz, app.js dosyanızı aşağıdaki kod parçacığı ile düzenleyin

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

Sonraki Adım: Uygulamanız için Modelleri tanımlayın, bunları gerektirir ve örneğin doğrudan CRUD işlemini gerçekleştirin

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 kullanımı

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

Her zaman mogoDB'ye bağlanmanıza gerek yok ....

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)

Bunun işe yaradığını buluyorum :)

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

Kabul edilen cevaplara dayanarak, basit bir yaklaşım kullanıyorum. Ancak bunu yalnızca bir dbsüre sonra yürütülecek olan iç işlevi kullanmak istiyorsanız kullanın . Örneğin: Ekspres rota işlevlerinde, alabileceğiniz en kolay yaklaşım budur.

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

Şimdi, db nesnesini istediğiniz diğer dosyalarda,

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
}