반응형
NodeJs 애플리케이션 및 모듈 전체에서 Mongodb에 대한 연결을 적절하게 재사용하는 방법
읽고 또 읽고 있는데, NodeJs 앱 전체에서 동일한 데이터베이스(MongoDb) 접속을 공유하는 최선의 방법이 무엇인지 아직도 헷갈립니다.앱을 시작할 때 연결을 열어 모듈 간에 재사용해야 하는 것으로 알고 있습니다.의 방법은 '다'입니다.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 db 인스턴스: mongo db db의 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
} );
다른 할 필요가 때, 다른 에 접속할 필요가 있을 때, 몽고에 접속할 수 ..js 할 수요.
var mongoUtil = require( 'mongoUtil' );
var db = mongoUtil.getDb();
db.collection( 'users' ).find();
이 " " "일 때" 입니다.require한에 'ᄃ, ㄴ/ㄹ 것 같다, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, _db ★★★★★★★★★★★★★★★★★」mongoUtil.getDb()는 항상 같은 인스턴스를 반환합니다.
코드는 테스트되지 않았습니다.
장소에서의 설정 오브젝트를 받아들이도록 조정할 수 있는 방법은 여러 가지가 있지만, 보다 현대적인 JS 구문을 사용하더라도 전반적으로 코드를 배치하는 방법과 유사합니다.원하는 경우 프로토타입 및 콜백으로 쉽게 다시 작성할 수 있습니다.
mongo.displays(mongo.displays)
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.module
const mongo = require('./mongo');
async function start() {
// other app startup stuff...
await mongo.init();
// other app startup stuff...
}
start();
some File.js
const { Users } = require('./mongo');
async function someFunction(userInfo) {
const user = await Users.addUser(userInfo);
return user;
}
다음은 go-oleg의 예를 바탕으로 한 현대 구문입니다.내 것은 테스트되고 작동한다.
코드에 코멘트를 넣었습니다.
./db/mongodb.dll
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.displaces
// 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.module
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를 사용하는 경우 요청 개체에서 DB 연결을 가져올 수 있는 mongo-express-req 모듈을 사용할 수 있습니다.
설치하다
npm install --save mongo-express-req
server.displaces
var app = require('express')();
var mongoExpressReq = require('mongo-express-req');
app.use(mongoExpressReq('mongodb://localhost/test'));
routes/users.module
app.get('/', function (req, res, next) {
req.db // => Db object
});
★★★★★★mongo-express-req유지보수가 안 되는 포크입니다.express-mongo-db.
인정된 답변에 근거한 테스트 완료 솔루션:
몽고드부틸js:
var MongoClient = require( 'mongodb' ).MongoClient;
var _db;
module.exports = {
connectToServer: function( callback ) {
MongoClient.connect( "<connection string>", function( err, client ) {
_db = client.db("<database name>");
return callback( err );
} );
},
getDb: function() {
return _db;
}
};
app.filename:
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;
activities.displays -- 루트:
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년의 설정입니다.
./discs/discloss.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.displaces
const mongo = require('./utils/database');
const express = require('express');
const app = express();
const boot = async () => {
await mongo.main();
app.listen(3000);
};
boot();
go-leg는 기본적으로 옳습니다만, 요즈음에는 mongodb 자체를 사용하고 싶지 않습니다.그 대신, 많은 「중요한 작업」을 할 수 있는 프레임워크를 사용해 주세요.
예를 들어, 몽구스는 가장 흔한 것 중 하나이다. 부분에서는 있습니다.server.js 삭제:
const mongoose = require('mongoose');
const options = {server: {socketOptions: {keepAlive: 1}}};
mongoose.connect(config.db, options);
셋업에 필요한 것은 이것뿐입니다.이제 코드 내 어디에서나 사용할 수 있습니다.
const mongoose = require('mongoose');
그리고 당신이 설정한 인스턴스가 있습니다.mongoose.connect
파티에 늦었지만 이 답변이 도움이 되었으면 합니다.이것은 기능 코드입니다.
db.deb.debooks(db.interface)
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.module
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.module.module.displaces
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라는 객체가 있습니다.거기에 속성을 붙여 루트 내부에서 액세스 할 수 있습니다.app.js 파일에서 mongo 연결을 인스턴스화하기만 하면 됩니다.
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추가 모듈이 필요 없습니다.
약속으로 연결을 초기화합니다.
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
})
})
다음은 TypeScript 및 ES6 기능과 구문을 사용하는 방법입니다.
db.ts
import { Db, MongoClient } from 'mongodb'
let client: MongoClient
let db: Db
const connectToDatabase = async () => {
client = new MongoClient('databaseURI')
await client.connect()
db = client.db('dbname')
}
export {
connectToDatabase,
client,
db,
}
인덱스.ts
import express from 'express'
import { someRouter } from './routes/someRoute'
import { connectToDatabase } from './db'
connectToDatabase().then(() => {
const app = express()
app.use('/someRoute', someRouter)
const port = process.env.PORT || 5000
app.listen(port, () => {
console.log(`Server is listening on port ${port}`)
})
})
routes/someRoute.ts
import express from 'express'
import { db } from '../db'
const someRouter = express.Router()
someRouter.route('/')
.get(async (req, res) => {
const results = await db.collection('collectionName').find().toArray()
return res.send(results)
})
export {
someRouter,
}
dbconnection.dbconnection 같은 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');
비동기 기능 내에서 이렇게 사용합니다.
db = await connection.connect();
이것이 효과가 있기를 바란다
이 방법은 잘 작동한다고 생각합니다. :)
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,
};
any File.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 };
조금 늦었지만 솔루션도 추가하겠습니다.이 답변에 비하면 훨씬 더 까다로운 접근법입니다.
어쨌든 MongoDB 버전 4.0 및 Node.js 3.0(또는 그 이후 버전)을 사용하는 경우에는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.급행 노선: 급행 노선.
mongo.displays(mongo.displays)
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.displaces
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
}
어플리케이션에서 mongoose를 사용하는 경우 다음 스니펫을 사용하여 app.js 파일을 편집합니다.
app.module
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)
Singleton Design Pattern을 사용하여 MongoDB 연결의 파일 간 사용을 확인할 수 있습니다.
Init.mjs
/* ################ Controller ################ */
import ctrlLib from '../../controller/lib.mjs';
/* ################ MongoDB ################ */
import mongodb from 'mongodb';
/* ################ Logs ################ */
import log from 'fancy-log';
import chalk from 'chalk';
/** Init MongoDB connection */
export class Init {
/**
* Check if its first time usage of this class.
If true set class instance to this that we always get same instance.
* Then get MongoDB details from config.yml and set as global.
* In the last step we return the class instance.
*/
constructor() {
if (Init.instance == null) Init.instance = this;
const config = ctrlLib.getConfig();
this.MongoURL = config.MongoDB.url;
this.MongoName = config.MongoDB.dbname;
({MongoClient: this.MongoClient} = mongodb);
return Init.instance;
}; // constructor(){
/** Connect to Database and return connection */
async connect() {
try {
const client = await this.MongoClient.connect(
this.MongoURL, {useNewUrlParser: true, useUnifiedTopology: true},
);
this.connection = {'db': client.db(this.MongoName), 'client': client};
return this.connection;
} // try {
catch (e) {
log( `${chalk.red.bold('❌ ERROR')} while try to connect to MongoDB DB
${chalk.white.bold('Error:\n')} ${e}` );
} // catch (e) {
}; // async connect() {
/**
* Return connection for cross file usage
* @return {object}
*/
getConnection() {return this.connection;};
}; // export class Init {
응용 프로그램
- 나중에 다른 파일에서 사용할 수 있도록 프로젝트 내에서 MongoDB 연결을 1배 더 길게 만드십시오.
/* ################ Services ################ */
import {Init} from './Init.mjs';
(async ()=>{
await new Init().connect();
})().catch(e=>{log('app.mjs - Catch error: ' + e);});
anyOtherFile.mjs
/* ################ Services ################ */
import {Init} from './Init.mjs';
/** Subclass of Search which contains lib functions */
class Lib {
/**
* Find data by using search query and return result.
* @param {string} collection - Name of collection
* @param {object} query - Search query
*/
async findOne(collection, query) {
const connection = new Init().getConnection();
return await connection.db.collection(collection).findOne(query);
}; // async findOne() {
}; // class Lib {
2022년 MongoClient 새 업데이트 업데이트
MongoUtil.js(데이터베이스 연결 및 반환 데이터베이스 인스턴스용)
const { MongoClient } = require('mongodb');
const uri = "your database connection url";
var _db;
module.exports = {
connectToServer: function (callback) {
MongoClient.connect(uri, { useNewUrlParser: true }, function (err, client) {
_db = client.db('testdb');
return callback(err);
});
},
getDb: function () { //this returns database instance
return _db;
}
};
app.js(mongoUtil을 Import하여 임의의 루트 또는 js에서 사용할 수 있습니다)
var mongoUtil = require('./mongoUtil');
mongoUtil.connectToServer(function (err, client) {
if (err) console.log(err);
console.log(`server is running`);
insertData(); //or do functions and db queries in any js
});
async function insertData() { //Functions should be async
var database = mongoUtil.getDb();
var movies = database.collection('movies');
const doc = {
title: "Movie title",
content: "Movie content",
}
const result = await movies.insertOne(doc);
console.log(`A document was inserted with the _id: ${result.insertedId}`);
}
@go-leg go @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ 。getDb(), 꼭 확인하겠습니다._db정의해야 합니다.있지 않은 는, 「」라고 .connectToServer()을 사용하다에는 전화하지.connectToServer() app.js그래서 내 코드가 깨끗해졌어
let getDb = async() => {
if(_db) {
return _db
} else {
_db = await connectToServer()
return _db
}
}
다음에 그냥 하면 돼, 전화하면 요.getDb()가 첫 번째 걸립니다.그리고 제가 관찰한 바로는 첫 통화에 64ms 정도 걸립니다.2~6ms로 하다.
평판이 나빠서 이렇게 대답한 겁니다.
오랜 노력 끝에 이 조작 방법을 사용하여 작업했습니다.이 링크에 따라주세요.이 링크도 좋은 해결책입니다.https://mrvautin.com/re-use-mongodb-database-connection-in-routes/
여러분, 2022년에는 재접속 로직이 필요 없습니다.Node.js MongoDB 드라이버가 이 모든 것을 처리합니다(v4+).
공식 문서에 설명된 대로 간단히 연결할 수 있습니다.이를 db.js 파일에 저장하면 앱 내 어디에서나 클라이언트 또는 DB를 가져올 수 있습니다.
import { MongoClient, ServerApiVersion } from 'mongodb'
const uri = `mongodb+srv://...`;
// Create a new MongoClient
export const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true, serverApi: ServerApiVersion.v1 });
export const db = client.db('your_db');
쿼리를 작성할 때는 try/catch를 사용하여 잠재적인 연결 오류를 캡처합니다.
try {
const res = await db.collection("testdata").insertOne({test: Math.random()});
console.log('Inserted', res);
} catch(e) {
console.error('MONGO ERROR', e);
}
AFAIK, 연결이 끊기면 몽고 드라이버는 계속 재시도합니다.
직접 사용해 보세요: 위의 코드를 setInterval에 넣고 인터넷 연결을 잠시 껐다가 다시 켜면 다운타임이 몇 시간 동안 지속된 후에도 Mongo는 자동으로 다시 연결됩니다.또, 접속이 다운하고 있을 때에 행해진 쿼리도 송신됩니다.
2023년 갱신
MongoDB 접속
const { MongoClient, ServerApiVersion } = require('mongodb');
const dbconfig = require('./config');
module.exports = {
client: client = new MongoClient(dbconfig.uri, { useNewUrlParser: true, useUnifiedTopology: true, serverApi: ServerApiVersion.v1 }),
connectToDB: async () => {
try {
await client.connect()
console.log('connected!')
} catch (err) {
console.log('Err', err)
}
}
}
컨트롤러 내
const db = require('../config/mongodb.connection')
const hha_data = db.client.db('hha-sit').collection('hnh-data')
exports.addNewCustomer = async (req, res) => {
try {
await db.connectToDB()
let result = await hha_data.findOne({}, { account_id: 'MDB829001337' })
console.log('result', result)
} catch (err) {
console.error('Connection Error !', err)
} finally {
await db.client.close()
}
res.send('Hi')
}
제안 사항이 있으시면 언제든지 수정해 주십시오.:)
이 방법은 올바르고 다음과 같은 방법으로 개선할 수 있습니다.
1. MongoClient 연결 기능을 모듈 내에 래핑하여 어플리케이션 전체에서 사용할 싱글톤 개체로 내보냅니다.이렇게 하면 MongoDB 서버에 대한 연결이 1개만 확립되어 모듈 전체에서 재사용되는지 확인할 수 있습니다.
2. 에러 처리를 코드에 추가하여 접속 장애와 같은 잠재적인 문제를 처리합니다.
3. 응용 프로그램 수명 동안 단일 연결을 유지하는 대신 MongoDB 네이티브 드라이버 연결 풀링 기능을 사용하십시오. 그러면 리소스가 소진되고 성능이 저하될 수 있습니다.
다음으로 개선된 구현의 예를 제시하겠습니다.
const MongoClient = require('mongodb').MongoClient;
let _db;
const connectToDb = async (url) => {
if (db) return db;
let client;
try {
client = await MongoClient.connect(url, {
useNewUrlParser: true,
useUnifiedTopology: true
});
_db = client.db();
} catch (err) {
console.error('Error connecting to MongoDB: ', err);
process.exit(1);
}
return _db;
};
module.exports = connectToDb;const connectToDb = require('./db');
const userModule = async (app) => {
const db = await connectToDb('mongodb://localhost:27017/marankings');
return {
addUser: () => console.log('add user'),
getAll: () => 'all users'
};
};
module.exports = userModule;const userModule = require('./userModule');
(async () => {
const users = await userModule();
console.log(users.getAll());
})();언급URL : https://stackoverflow.com/questions/24621940/how-to-properly-reuse-connection-to-mongodb-across-nodejs-application-and-module
반응형
'programing' 카테고리의 다른 글
| ng-model 입력 유형 'number'는 angularjs가 작동하지 않습니다. (0) | 2023.03.23 |
|---|---|
| Angular에서 $log.debug를 설정/해제하는 방법JS (0) | 2023.03.23 |
| ASP에서 파일을 다운로드합니다.Angular를 사용하는 NET Web API 메서드JS (0) | 2023.03.23 |
| Android에서 요청을 통해 JSON 개체를 전송하는 방법은 무엇입니까? (0) | 2023.03.23 |
| 스냅샷을 생성할 때 Jest/Enzym ShowlowWrapper가 비어 있습니다. (0) | 2023.03.23 |