Javascript Mongoose错误：模式没有'；填充时未注册模型

我正在尝试加入两个集合，并能够获得组合数据。为了使用Mongoose实现这一点，我应该使用填充语法来实现这一点。我收到一个错误，该架构尚未注册为“User_Fb”。从我的代码中，我已经导出了server.js中所需的模型和参数，但是错误仍然出现。我做错了什么

feed_post.model.js

var mongoose = require('mongoose');
var conn_new_app     = mongoose.createConnection('mongodb://localhost/new_app');
var User_fb = require('../models/fb_db.model');

var Schema = mongoose.Schema;
var feed_postSchema = new Schema({
    user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
    content: String,
    location: String,
    image: [{ type : String }]
});

var Feed_Post = conn_new_app.model('Feed_Post', feed_postSchema);

module.exports = Feed_Post;

module.exports = function (connection) {
    var mongoose = require('mongoose');
    var Schema = mongoose.Schema;

    var feed_postSchema = new Schema({
        user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
        content: String,
        location: String,
        image: [{ type : String }]
    });

    return connection.model('Feed_Post', feed_postSchema);;
}

fb_db.model.js

var mongoose = require('mongoose');
var conn_new_app     = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('../models/feed_post.model');

var user_fb = new mongoose.Schema({
    name: String,
    location: String,
    fb_id: Number
});

var User_Fb = conn_new_app.model('User_Fb', user_fb);

module.exports = User_Fb;

module.exports = function (connection) {
    var mongoose = require('mongoose');
    var Schema = mongoose.Schema;

    var user_fb = new mongoose.Schema({
        name: String,
        location: String,
        fb_id: Number
    });

    return connection.model('User_FB', user_fb);;
}

server.js

var express = require('express'),

mongoose = require('mongoose'),
User = require('./app/models/user.model'),
Post = require('./app/models/post.model'),
Maptest = require('./app/models/maptest.model'),
Feed_Post = require('./app/models/feed_post.model'),
User_Fb = require('./app/models/fb_db.model'),

app = express();

app.get('/testget', function(req,res){
    Feed_Post.findOne().populate('user_id').exec(function(err, c) {
        if (err) { return console.log(err); }

        console.log(c.fk_user.userName);
    });
});

var express = require('express'),
app = express(),

mongoose = require('mongoose'),
conn_new_app = mongoose.createConnection('mongodb://localhost/new_app'),
User_Fb = require('./app/models/fb_db.model')(conn_new_app),
Feed_Post = require('./app/models/feed_post.model')(conn_new_app);

app.get('/testget', function(req,res){
    Feed_Post.find().populate('user_id').exec(function(err, res) {
        if (err) { return console.log(err); }
        console.log(res);
    });
});

由Pier Luc Gendreau答案更新

var express = require('express');
var mongoose = require('mongoose');

var app = express();
var conn_new_app = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('./app/models/feed_post.model')(conn_new_app);

app.get('/testget', function(req,res){
  Feed_Post.findOne().populate('user_id').exec(function(err, c) {
    if (err) { return console.log(err); }
    console.log(c.fk_user.userName);
  });
});

module.exports = function (connection) {
  var mongoose = require('mongoose');
  var Schema = mongoose.Schema;

  var feed_postSchema = new Schema({
    user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
    content: String,
    location: String,
    image: [{ type : String }]
  });

  return connection.model('Feed_Post', feed_postSchema);;
}

fb_db.model.js

var mongoose = require('mongoose');
var conn_new_app     = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('../models/feed_post.model');

var user_fb = new mongoose.Schema({
    name: String,
    location: String,
    fb_id: Number
});

var User_Fb = conn_new_app.model('User_Fb', user_fb);

module.exports = User_Fb;

module.exports = function (connection) {
    var mongoose = require('mongoose');
    var Schema = mongoose.Schema;

    var user_fb = new mongoose.Schema({
        name: String,
        location: String,
        fb_id: Number
    });

    return connection.model('User_FB', user_fb);;
}

feed_post.model.js

var mongoose = require('mongoose');
var conn_new_app     = mongoose.createConnection('mongodb://localhost/new_app');
var User_fb = require('../models/fb_db.model');

var Schema = mongoose.Schema;
var feed_postSchema = new Schema({
    user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
    content: String,
    location: String,
    image: [{ type : String }]
});

var Feed_Post = conn_new_app.model('Feed_Post', feed_postSchema);

module.exports = Feed_Post;

module.exports = function (connection) {
    var mongoose = require('mongoose');
    var Schema = mongoose.Schema;

    var feed_postSchema = new Schema({
        user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
        content: String,
        location: String,
        image: [{ type : String }]
    });

    return connection.model('Feed_Post', feed_postSchema);;
}

server.js

var express = require('express'),

mongoose = require('mongoose'),
User = require('./app/models/user.model'),
Post = require('./app/models/post.model'),
Maptest = require('./app/models/maptest.model'),
Feed_Post = require('./app/models/feed_post.model'),
User_Fb = require('./app/models/fb_db.model'),

app = express();

app.get('/testget', function(req,res){
    Feed_Post.findOne().populate('user_id').exec(function(err, c) {
        if (err) { return console.log(err); }

        console.log(c.fk_user.userName);
    });
});

var express = require('express'),
app = express(),

mongoose = require('mongoose'),
conn_new_app = mongoose.createConnection('mongodb://localhost/new_app'),
User_Fb = require('./app/models/fb_db.model')(conn_new_app),
Feed_Post = require('./app/models/feed_post.model')(conn_new_app);

app.get('/testget', function(req,res){
    Feed_Post.find().populate('user_id').exec(function(err, res) {
        if (err) { return console.log(err); }
        console.log(res);
    });
});

---

看起来您正在为每个模型创建不同的数据库连接，从而将模型彼此隔离。Mongoose必须假设这种隔离，因为它们可能存在于不同的数据库甚至数据库服务器上

---

尝试连接一次，定义模型时只需调用

mongoose.model（）

，而不是

connection.model（）

。默认情况下，Mongoose是单例的。

问题在于，您在每个模型中都创建了一个新连接，因此最终会得到一堆不同的连接对象。即使它们指向同一个数据库，mongoose模型也不知道其他连接。您应该在主应用程序中创建连接对象，然后传递它

server.js

var express = require('express');
var mongoose = require('mongoose');

var app = express();
var conn_new_app = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('./app/models/feed_post.model')(conn_new_app);

app.get('/testget', function(req,res){
  Feed_Post.findOne().populate('user_id').exec(function(err, c) {
    if (err) { return console.log(err); }
    console.log(c.fk_user.userName);
  });
});

module.exports = function (connection) {
  var mongoose = require('mongoose');
  var Schema = mongoose.Schema;

  var feed_postSchema = new Schema({
    user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
    content: String,
    location: String,
    image: [{ type : String }]
  });

  return connection.model('Feed_Post', feed_postSchema);;
}

然后修改模型，使其实际上是一个函数：

feed\u post.model.js

var express = require('express');
var mongoose = require('mongoose');

var app = express();
var conn_new_app = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('./app/models/feed_post.model')(conn_new_app);

app.get('/testget', function(req,res){
  Feed_Post.findOne().populate('user_id').exec(function(err, c) {
    if (err) { return console.log(err); }
    console.log(c.fk_user.userName);
  });
});

module.exports = function (connection) {
  var mongoose = require('mongoose');
  var Schema = mongoose.Schema;

  var feed_postSchema = new Schema({
    user_id:  { type: Schema.Types.ObjectId, ref: 'User_Fb' },
    content: String,
    location: String,
    image: [{ type : String }]
  });

  return connection.model('Feed_Post', feed_postSchema);;
}

另外，就像阿德里安提到的，你可以把猫鼬当作单身汉。但是，我确实建议像您那样使用

createConnection

，因为如果您需要第二个连接，就不必重构第一个数据库的连接代码。

如果您（真的）使用多个mongoDB连接

---

我确实意识到OP的情况并非如此，但如果您真正使用多个连接，则必须在使用.populate（）时提供模型，因为mongoose只能在同一个连接上“查找”模型。 例如：

var db1 = mongoose.createConnection('mongodb://localhost:27017/gh3639');
var db2 = mongoose.createConnection('mongodb://localhost:27017/gh3639_2');
var userSchema = mongoose.Schema({
  "name": String,
  "email": String
});

var customerSchema = mongoose.Schema({
  "name" : { type: String },
  "email" : [ String ],
  "created_by" : { type: mongoose.Schema.Types.ObjectId, ref: 'users' },
});

var User = db1.model('users', userSchema);
var Customer = db2.model('customers', customerSchema);

正确：

Customer.findOne({}).populate('created_by', 'name email', User)

或

不正确（产生“模式尚未为模型注册”错误）：

---

这就是我所要做的

Customer.findOne（{}）.populate（{path:'created_by'，model:User}）

而不是这个

Category.findOne（{}）.populate（{'author'}）

在我的例子中，这个问题是因为我没有将

ref模型

包含到应用程序中。

嗨，我理解您创建新数据库连接的意思。我的其他模型实际上使用了另一个数据库的名称，这就是我这样做的原因。在遵循您的建议/指示后，我仍然收到相同的错误。我在问题中更新了我的代码。我刚刚注意到你也有一个打字错误。您的型号名称和参考不匹配：

User\u Fb

vs.

User\u Fb

Oh！如此粗心。谢谢Pier Luc Gendreau！多亏了你，现在它开始工作了！很高兴我能帮上忙，这是我们中最好的！此外，最好对变量使用lowerCamelCase，而不是下划线。这里有一些风格指南，最值得注意的是，最近它已经收集了相当多的蒸汽。我现在就来看看。再次感谢D