node.js - NodeJS类结构中的MongoDB

Question

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

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

mongo.connect(url, function(err, client){//做一些CRUD操作});

但我想知道是否有一种方法可以打开与数据库的连接，跨类访问它，然后在完成类工作后关闭它。

例如:

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 docs 中看到了更多信息.也许类似的东西会起作用？

//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. 轻松将您选择的数据库模块替换为另一个(如果需要)。

我已经创建了我在我的 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
}

关于我完整的库访问你可以引用here