Nodejs mongoose 取 model 问题

Nodejs mongoose 取 model 问题

我有两个文件

BlogDao.js 和 BaseDao.js

BlogDao.js 内容
var MongoseClient = require("./BaseDao.js");
var mc;
if(mc === undefined){
mc = new MongoseClient();
}

var BlogDao = function(){

var BlogSchme = require("../entity/Blog.js");
var mongoose = mc.getMongoose();
**    var model =  mongoose.model(“blogs”,BlogSchme);**
**   var md = mc.getModel(“blogs”,BlogSchme);**
this.add = function(data) {
console.log(“entry blogDao add …”);
var entity = new model({“title”:data.title, “author”:“lzj”,“comments”:[{“body”:data.content,“date”:new Date()}]});
mc.add(entity);
console.log(“leave blogDao add …”);
};
this.update = function(data){
// mongo.update(data);
};
this.delete = function(data){
// mongo.delete(data);
};
this.findById = function(id){
md.findById(id,function(err,doc){

    });
var result = null;
model.findById(id,function(err,doc){

    console.log("11111111111111");
    if(err){
        console.log(err);
    }else{
        result = doc;
    }
    console.log(doc);
    console.log("------------------------");
    console.log(result);
});
// mc.findById(model,id);
console.log(“22222222222”);
return result;
}

}

BaseDao.js 内容
var MongoseClient = function() {
var mongoose = require(‘mongoose’);
mongoose.connect(‘mongodb://127.0.0.1:27017/blog’);
//确保单例
var unique = this;
if(MongoseClient.unique !== undefined){
return MongoseClient.unique;
}
this.getMongoose = function(){
return mongoose;
};
this.getModel = function (collName, collEntity) {
if (collName === undefined || collEntity === undefined) {
return null;
}
var model = mongoose.model(collName, collEntity);
return model;

}
}

在BlogDao.js文件中发现 变量model 和 md 不一样，根据id查询的时候model 这个可以正常查询，而md不行。请教这是什么原因？


2 回复

在你的代码中，model 和 md 的区别在于它们的定义方式不同，这导致了在使用时的行为差异。

问题分析

  1. model 的定义

    var BlogSchme = require("../entity/Blog.js");
var mongoose = mc.getMongoose();
var model = mongoose.model("blogs", BlogSchme);

  2. md 的定义

    var md = mc.getModel("blogs", BlogSchme);

原因分析

  • model 是直接通过 mongoose.model() 方法创建的模型实例。
  • md 是通过 BaseDao.js 中的 getModel() 方法获取的模型实例。

解决方案

由于 BaseDao.js 中的 getModel() 方法只是简单地调用了 mongoose.model() 方法，并且返回了相同的模型实例，因此在大多数情况下，model 和 md 应该是相同的。但你的代码中存在一些潜在的问题：

  1. 异步操作的顺序问题 在 findById 方法中，你尝试同步返回查询结果 result，但这在异步回调中是不可行的。你需要处理异步回调。

  2. 代码重复 你在 findById 方法中同时调用了 mc.findById(model, id) 和 model.findById(id, callback)，这会导致不必要的重复查询。

示例代码修正

你可以简化 findById 方法，只使用 model 来进行查询，并正确处理异步回调：

var BlogDao = function () {
    var BlogSchme = require("../entity/Blog.js");
    var mongoose = mc.getMongoose();
    var model = mongoose.model("blogs", BlogSchme);

    this.add = function (data) {
        console.log("entry blogDao add …");
        var entity = new model({
            "title": data.title,
            "author": "lzj",
            "comments": [{ "body": data.content, "date": new Date() }]
        });
        mc.add(entity);
        console.log("leave blogDao add …");
    };

    this.update = function (data) {
        // mongo.update(data);
    };

    this.delete = function (data) {
        // mongo.delete(data);
    };

    this.findById = function (id, callback) {
        model.findById(id, function (err, doc) {
            if (err) {
                console.log(err);
                callback(err, null);
            } else {
                console.log(doc);
                console.log("------------------------");
                callback(null, doc);
            }
        });
    };
};

module.exports = BlogDao;

关键点总结

  1. 避免同步返回异步操作的结果：在处理异步回调时，使用回调函数传递结果。
  2. 减少重复代码：确保每个方法只执行一次数据库查询。

通过这种方式，你可以确保 findById 方法正确地处理异步查询，并且不会因为重复查询而导致错误。


在你的代码中，model 和 md 的确是不同的变量，但它们理论上应该是一致的。model 是直接通过 mongoose.model 方法创建的模型，而 md 是通过 BaseDao.js 中的 getModel 方法获取的模型。

在 BlogDao.js 文件中的 findById 方法中，你使用了两种方式来查找数据，一种是通过 model，另一种是通过 md。这里的问题可能在于 BaseDao.js 中 getModel 方法的实现方式导致了 md 模型与 model 模型不一致。

示例代码修改

首先，确保 BaseDao.js 中 getModel 方法的实现方式正确：

// BaseDao.js
var MongoseClient = function() {
    var mongoose = require('mongoose');
    mongoose.connect('mongodb://127.0.0.1:27017/blog');

    // 确保单例
    var unique = this;
    if (MongoseClient.unique !== undefined) {
        return MongoseClient.unique;
    }

    this.getMongoose = function() {
        return mongoose;
    };

    this.getModel = function(collName, collEntity) {
        if (collName === undefined || collEntity === undefined) {
            return null;
        }
        return mongoose.model(collName, collEntity);
    };
};

module.exports = MongoseClient;

然后，在 BlogDao.js 中使用 getModel 方法来获取模型，并确保 BlogSchme 正确加载：

// BlogDao.js
var MongoseClient = require("./BaseDao.js");

var mc;
if (mc === undefined) {
    mc = new MongoseClient();
}

var BlogDao = function() {
    var BlogSchema = require("../entity/Blog.js");
    var mongoose = mc.getMongoose();

    var model = mongoose.model("blogs", BlogSchema);
    var md = mc.getModel("blogs", BlogSchema);

    this.add = function(data) {
        console.log("entry blogDao add …");
        var entity = new model({
            "title": data.title,
            "author": "lzj",
            "comments": [{ "body": data.content, "date": new Date() }]
        });
        mc.add(entity);
        console.log("leave blogDao add …");
    };

    this.findById = function(id) {
        md.findById(id, function(err, doc) {
            if (err) {
                console.log(err);
            } else {
                console.log(doc);
            }
        });

        model.findById(id, function(err, doc) {
            if (err) {
                console.log(err);
            } else {
                console.log(doc);
            }
        });
    };
};

module.exports = BlogDao;

解释

  1. 单例模式：确保 MongoseClient 是一个单例，避免重复连接 MongoDB。
  2. getModel 方法：确保 getModel 方法正确返回模型实例。
  3. 模型一致性：在 BlogDao.js 中，确保 model 和 md 使用相同的 BlogSchema 实例。

这样，model 和 md 都应该能正常查询数据库。如果仍然存在问题，建议检查 BlogSchema 是否正确加载以及是否正确地定义了 Schema。

回到顶部