NodeJS 类结构中的 MongoDB

Question

有没有办法在 NodeJS 的类结构中使用 MongoDB？

我知道您可以在连接方法中对数据库进行 CRUD 操作，例如

mongo.connect(url, function(err, client){//do some CRUD operation});

但我想知道是否有办法打开与数据库的连接，可以在整个班级中访问它，然后在完成班级工作后关闭它。

例如：

class MyClass {
    constructor(databaseURL) {
      this.url = databaseURL;
    }

    async init() {
      //make connection to database
    }

    async complete_TaskA_onDB() {
      //...
    }

    async complete_TaskB_onDB() {
      //...
    }

    async close_connection() {
      //close connection to database
    }
}

编辑：

我刚刚在Node.JS Mongo 文档中发现了更多信息。也许类似的东西会起作用？

//constructor()
this.db = new MongoClient(new Server(dbHost, dbPort));

//init()
this.db.open();

//taskA()
this.db.collection(...).update(...);

//close_connection()
this.db.close();

Answer 1

您可以创建一个类，该类将充当任何核心库的包装器，这样做将为您带来以下优势：

使用您自己的服务包装任何核心模块将允许您：

1. 创建一个可重用的服务，您可以在应用程序中的多个组件上使用它。
2. 规范模块的 API，并添加更多您的应用需要而模块不提供的方法。
3. 轻松地将您选择的 DB 模块替换为另一个（如果需要）。

我已经创建了我在我的项目中使用它的服务MongoDB：

var mongoClient = require("mongodb").MongoClient,
  db;

function isObject(obj) {
  return Object.keys(obj).length > 0 && obj.constructor === Object;
}

class mongoDbClient {
  async connect(conn, onSuccess, onFailure){
    try {
      var connection = await mongoClient.connect(conn.url, { useNewUrlParser: true });
      this.db = connection.db(conn.dbName);
      logger.info("MongoClient Connection successfull.");
      onSuccess();
    }
    catch(ex) {
      logger.error("Error caught,", ex);
      onFailure(ex);
    }
  }

  async getNextSequence(coll) {
    return await this.db.collection("counters").findOneAndUpdate({
        _id: coll
      },
      {$inc: {seq: 1}},
      {projections: {seq: 1},
        upsert: true,
        returnOriginal: false
      }
    );
  }

  async insertDocumentWithIndex(coll, doc) {
    try {
      if(!isObject(doc)){
        throw Error("mongoClient.insertDocumentWithIndex: document is not an object");
        return;
      }
      var index = await this.getNextSequence(coll);
      doc.idx = index.value.seq;
      return await this.db.collection(coll).insertOne(doc);
    }
    catch(e) {
      logger.error("mongoClient.insertDocumentWithIndex: Error caught,", e);
      return Promise.reject(e);
    }
  }

  async findDocFieldsByFilter(coll, query, projection, lmt) {
    if(!query){
      throw Error("mongoClient.findDocFieldsByFilter: query is not an object");
    }
    return await this.db.collection(coll).find(query, {
      projection: projection || {},
      limit: lmt || 0
    }).toArray();
  }

  async findDocByAggregation(coll, query) {
    if(!query.length){
      throw Error("mongoClient.findDocByAggregation: query is not an object");
    }
    return this.db.collection(coll).aggregate(query).toArray();
  }

  async getDocumentCountByQuery(coll, query) {
    return this.db.collection(coll).estimatedDocumentCount(query || {})
  }

  async findOneAndUpdate(coll, query, values, option) {
    if(!(isObject(values) && isObject(query))){
      throw Error("mongoClient.UpdateDocument: values and query should be an object");
    }
    return this.db.collection(coll).findOneAndUpdate(query, {$set : values}, option || {})
  }

  async modifyOneDocument(coll, query, values, option) {
    if(!(isObject(values) && isObject(query))){
      throw Error("mongoClient.ModifyOneDocument: values, query and option should be an object");
    }
    return await this.db.collection(coll).updateOne(query, values, option || {})
  }

  async close() {
    return await this.db.close();
  }
}

module.exports = {
  mongoDbClient: mongoDbClient
}

对于我的完整库访问，您可以参考这里