NodeJs एप्लिकेशन और मॉड्यूल में Mongodb से कनेक्शन का पुनः उपयोग कैसे करें

Question

मैं पढ़ रहा हूं और पढ़ रहा हूं और अभी भी इस बात पर असमंजस में हूं कि एक ही डेटाबेस (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;

अब मुझे भयानक एहसास हो रहा है कि यह गलत है इसलिए इस दृष्टिकोण के साथ कोई स्पष्ट समस्याएं हैं और यदि ऐसा है तो इसे बेहतर कैसे बनाएं?

Comments

इसी तरह का सवाल मैंने कुछ दिन पहले पूछा था। stackoverflow.com/questions/24547357/…

— साल्वाडोर डाली

चेक mongoist ड्राइवर। यह " async के साथ बनाया गया है / मन में प्रतीक्षा " और lazily निर्यात कनेक्शन की तरह अनुमति देता है module.exports = mongoist(connectionString);। ( connectionStringMongoDB मैनुअल के बारे में पढ़ें ।)

— एलेक्जेंडर निल

Answer 1

आप एक ऐसा mongoUtil.jsमॉड्यूल बना सकते हैं, जिसमें दोनों मूंगो से जुड़ने के लिए फंक्शन हों और एक मोंगो डीबी उदाहरण लौटाएं:

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

और फिर, जब आपको किसी अन्य .jsफाइल की तरह मोंगो तक पहुंच की आवश्यकता होती है , तो आप ऐसा कर सकते हैं:

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

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

इसका कारण यह है कि नोड में, जब मॉड्यूल requireडी होते हैं, तो वे केवल एक बार लोड / खट्टा हो जाते हैं ताकि आप केवल एक ही उदाहरण के साथ समाप्त हो जाएंगे _dbऔर mongoUtil.getDb()हमेशा उसी उदाहरण को वापस करेंगे।

नोट, कोड परीक्षण नहीं किया गया।

Comments

महान उदाहरण! हालांकि, मेरा एक सवाल है। अपने ऐप को कई समूहों के साथ चलाने पर यह कैसे काम करेगा? क्या यह कनेक्शन का एक और उदाहरण स्पिन करेगा या स्रोत से मौजूदा कनेक्शन का उपयोग करेगा?

— फरहान अहमद

जब आप मूंगो कनेक्शन के बीच में मर जाते हैं तो आप मामले को कैसे संभालेंगे? GetDb () में सभी कॉल उस स्थिति में विफल हो जाएंगी जब तक नोड एप्लिकेशन को पुनरारंभ नहीं किया जाता है।

— अयन

मैंने इस कोड की कोशिश की, लेकिन जब मैं mongoUtil.getDb () करता हूं तो मुझे अशक्त हो गया, मुझे नहीं पता कि वह क्यों है।

— केमिंग

@KemingZeng - आपको यह सुनिश्चित करने की आवश्यकता है कि mongoUtil का उपयोग करने वाले सभी मॉड्यूल app.jsकॉलबैक फ़ंक्शन के भीतर आयात किए जाते हैं connectToServer। यदि आप requireउन्हें app.jsपहले _dbसेट करते हैं, तो आपको अन्य मॉड्यूल में अपरिभाषित त्रुटियां मिलेंगी।

— माइक आर

के रूप में mongoDB संस्करण 4 यह होना चाहिए var database = mongoUtil.getDb(); database.db().collection( 'users' )।

— जूलियन वीरकैंप

Answer 2

स्थानों में कॉन्फ़िगरेशन ऑब्जेक्ट्स को स्वीकार करने के लिए कई तरीके हो सकते हैं, लेकिन कुल मिलाकर यह समान है कि आपने अपने कोड को कैसे निर्धारित किया है, और अधिक आधुनिक जेएस सिंटैक्स के साथ। यदि आपकी आवश्यकता है तो आसानी से प्रोटोटाइप और कॉलबैक में फिर से लिखा जा सकता है।

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

Comments

यह सबसे साफ

— सुथरा

मुझे लगता है कि यह उत्तर लगभग एक वर्ष पुराना है और मैं वास्तव में अधिक जानकारी की उम्मीद नहीं करता हूं, लेकिन ऐसा लगता है कि मैं जिस दृष्टिकोण का उपयोग करना चाहता हूं वह अभी तक मैं शून्य किस्मत वाले हूं जो विनाशकारी उपयोगकर्ता ऑब्जेक्ट को मोंगो फ़ाइल से बाहर खींच रहा है। मेरे पास आपके someFile.js के समान एक फ़ाइल है, लेकिन पंक्ति 4 जहाँ आप Users को कॉल करते हैं ।addUser हमेशा मेरे लिए उड़ाता है - कहता है कि उपयोगकर्ता अपरिभाषित हैं। क्या कोई स्पष्ट टुकड़ा है जो मुझे याद आ रहा है?

— रोब ई।

मैंने एक नया प्रश्न तैयार किया क्योंकि यह मुझे बहुत परेशान कर रहा है।

— रोब ई।

यह तकनीकी रूप से काम नहीं करना चाहिए। पहले कॉल में ऑब्जेक्ट को कैश करना होगा। इस मामले में, यह केवल निर्माता द्वारा लौटाए गए ऑब्जेक्ट को कैश करेगा। बाद में 'init' कॉल करने का उस पर कोई प्रभाव नहीं पड़ता है जो वापस आ जाएगा। इसलिए यह कॉन्स्ट {{}} की आवश्यकता होती है ('./ मोंगो') विफल होना चाहिए क्योंकि कैश्ड परिणाम पर कोई 'उपयोगकर्ता' संपत्ति नहीं होगी।

— 21

आवश्यकता है। कैश ऑब्जेक्ट के संदर्भ को संग्रहीत करता है, जो उस ऑब्जेक्ट की आवश्यकता वाली सभी फ़ाइलों के बीच साझा किया जाता है। प्रोग्राम के अन्य हिस्सों (या यहां तक ​​कि अगर आप टाइमर का उपयोग करते हैं, तो स्वयं) से कार्यों द्वारा उत्परिवर्तित होने वाली वस्तुएं। आप इसे जल्दी से स्वयं परीक्षण कर सकते हैं, लेकिन मैंने एक त्वरित पेन को एक साथ डेमो के लिए फेंक दिया: codeandbox.io/s/awesome-water-cexno

— EddieDean

Answer 3

गो-ओलेग के उदाहरण के आधार पर, मैं इसे समकालीन सिंटैक्स के साथ कैसे करता हूं। मेरा परीक्षण और कार्यात्मक है।

मैंने कोड में कुछ टिप्पणियाँ रखीं।

./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: '[e-mail]',
     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 }

Comments

अपने पहले स्निपेट में पकड़ने की कोशिश जरूरी है? कनेक्ट फ़ंक्शन एक async फ़ंक्शन है। नोड शैली कॉलबैक का उपयोग करके त्रुटि पहले से ही पकड़ी जा रही है।

— शैंक

यह एक बहुत ही चौकस प्रश्न है जो मुझे पसंद है। मुझे यकीन है कि आप निवास स्थान में कोड का अध्ययन किए बिना इसके करीब नहीं होंगे। कोड निष्पादन के दौरान सीमित रास्ते हो सकते हैं। मैंने इसे ज्यादातर यह दिखाने के लिए जोड़ा कि आप वहां कस्टम हैंडलर लगा सकते हैं और क्योंकि मैं async फ़ंक्शंस में कोशिश / कैच को शामिल करने के लिए डिफ़ॉल्ट हूं। यह बस एक हुक बिंदु है। हालांकि अच्छा सवाल है। यदि आप एक अतिरिक्त नोट पाते हैं तो मैं अपडेट करूंगा।

— agm1984

हर बार अगर मैं getDB () को कॉल करता हूं तो यह नए कनेक्शन बनाएगा, है ना?

— विनय पंड्या

Answer 4

यदि आप एक्सप्रेस का उपयोग कर रहे हैं, तो आप एक्सप्रेस-मोंगो-डीबी मॉड्यूल का उपयोग कर सकते हैं जो आपको अनुरोध ऑब्जेक्ट में डीबी कनेक्शन प्राप्त करने की अनुमति देता है।

इंस्टॉल

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

Answer 5

गो-ऑलीग मूल रूप से सही है, लेकिन इन दिनों में आप (शायद) स्वयं "मोंगोडब" का उपयोग नहीं करना चाहते हैं, बल्कि कुछ रूपरेखा का उपयोग करें, जो आपके लिए बहुत सारे "गंदे काम" करेंगे।

उदाहरण के लिए, मैंगोज़ सबसे आम में से एक है। यह हमारी प्रारंभिक server.jsफ़ाइल में है:

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

यह सब कुछ है जो इसे स्थापित करने के लिए आवश्यक है। अब इसे अपने कोड में कहीं भी उपयोग करें

const mongoose = require('mongoose');

और आपको वह उदाहरण मिलता है, जिसके साथ आप सेट होते हैं mongoose.connect

Comments

आम एक ORM है। उसी के लिए संभावित नुकसान के बारे में जानने के लिए इसे पढ़ें । इसमें कोई संदेह नहीं है कि ओआरएम विकास और सीखने की प्रक्रिया के लिए उपयोग किए जाते हैं लेकिन उत्पादन के लिए नहीं। बस इसे ध्यान में रखें

— सरस आर्य

Mongoose को स्कीमा की भी आवश्यकता होती है। मैं Neo4j के साथ बहुभुज दृढ़ता के हिस्से के रूप में MongoDB पैकेज का उपयोग कर रहा हूं, इसलिए आवश्यकतानुसार दस्तावेज़ गुणों को परिभाषित करना अच्छा है।

— agm1984

Answer 6

कनेक्शन को वादा के रूप में शुरू करें:

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

Answer 7

स्वीकृत उत्तर के आधार पर एक परीक्षित समाधान:

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;

गतिविधियाँ .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;

Comments

यह उत्तर पूर्ण और कार्यात्मक है।

— अहमद शरीफ

Answer 8

यहाँ 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();

Answer 9

हम dbconnection.js की तरह एक dbconnection फ़ाइल बना सकते हैं

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

आशा है कि यह काम करेगा

Answer 10

मुझे इसके लिए थोड़ा देर हो गई है, लेकिन मैं अपना समाधान भी जोड़ूंगा। यहां के जवाबों की तुलना में यह बहुत अच्छा दृष्टिकोण है।

वैसे भी यदि आप 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");
}

इसने मेरे लिए ठीक काम किया। आशा करता हूँ की ये काम करेगा।

Answer 11

मुझे पार्टी में देर हो रही है, लेकिन उम्मीद है कि यह जवाब किसी की मदद करेगा, यह एक कार्यात्मक कोड है:

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}

हम एक फ़ंक्शन को मूंगो से कनेक्ट करने के लिए निर्यात करते हैं और दूसरा कनेक्शन प्राप्त करने के लिए इंस्टेंस्ट को प्राप्त करने के लिए।

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

Answer 12

जैसा कि यह एक्सप्रेस के साथ टैग किया गया है, मैंने सोचा कि मैं उल्लेख करूंगा कि एक्सप्रेस में मार्गों के बीच डेटा साझा करने की सुविधा है। 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और इसके लिए अतिरिक्त मॉड्यूल की आवश्यकता नहीं है।

Comments

मुझे यह सबसे साफ तरीका लगता है। क्या हमारे पास इस दृष्टिकोण के लिए कोई संभावित कमियां हैं? मैं इसका उपयोग कर रहा हूं और मुझे बहुत अच्छा लग रहा है, मेरी सीखों को साझा करेगा।

— प्रिया रंजन सिंह

@PriyaRanjanSingh ईमानदार होने के लिए, मैं किसी भी कमियों के बारे में नहीं जानता, लेकिन मैं इस पर कोई विशेषज्ञ नहीं है। मैंने शोध करने के बाद इस विधि की खोज की क्योंकि मैंने अन्य तरीकों को अनजाने में पाया और मैं अपने स्वयं के लाभ के लिए अधिक समझदार कोड क्लीनर के बाद था। उम्मीद है कि कोई और जानकार खुद को उजागर करने में सक्षम होगा अगर कोई कमियां हैं। मैं इस पद्धति का उपयोग बिना किसी मुद्दे के कुछ समय के लिए कर रहा हूं और यह अच्छी तरह से काम करता है।

— होप्पो

Answer 13

यदि आप अपने आवेदन में mongoose का उपयोग करने का विकल्प चुनते हैं, तो निम्न स्निपेट के साथ अपनी 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 से कनेक्ट करने की जरूरत नहीं है ....

Answer 14

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

Comments

क्या आप कृपया एक छोटा विवरण जोड़ सकते हैं?

— RtmY

Answer 15

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)

Answer 16

मुझे यह अच्छी तरह से लगता है :)

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

Comments

उत्तर के साथ टैग किया गया है javascript, नहीं लगता कि टाइपस्क्रिप्ट उत्तर उपयुक्त है।

— केपीओपीओजी