具有不同对象方法的 Mongoose 多类型模式答案

【问题标题】：Mongoose multi type schema with different object methods具有不同对象方法的 Mongoose 多类型模式
【发布时间】：2015-11-09 02:19:29
【问题描述】：

当我有一个具有多类型属性的集合架构时。喜欢它可以是数字或字符串

我为此使用了 mongoose 的混合类型，但所有验证都消失了。

问题：

var employeeSchema = mongoose.Schema({
    _id:false,
    title:string,
    ...
});

EmployeeSchema.methods.(....)//add some methods

var GroupSchema = ({
     visitor: {},  // visitor can be an Employee schema or a string of person name
     note: string,
     time: Date
},{collection:'group'});

如何在 groupSchema 中定义访问者：

验证检查匹配字符串或保存中的员工。
如果访问者是员工，则从数据库读取数据时，我可以访问 Employee 方法。

【问题讨论】：

标签： node.js mongodb mongoose

【解决方案1】：

您在这里所追求的实际上是一种“多态性”，或者我们通常如何在数据库中将其实现为“鉴别器”。这里的基础是一种形式的 Object 继承自另一种形式，但它是自己的对象，具有自己的独特属性以及关联的方法。

这实际上比仅仅区分普通的“字符串”和更具体的对象更好，而且实现起来相当简单。举个例子：

var async     = require('async'),
    util      = require('util'),
    mongoose  = require('mongoose'),
    Schema    = mongoose.Schema;

mongoose.connect('mongodb://localhost/company');


function BaseSchema() {

  Schema.apply(this,arguments);

  this.add({
    name: String
  });

}

util.inherits(BaseSchema,Schema);

var personSchema = new BaseSchema();

personSchema.methods.speak = function() {
  console.log( "my name is %s",this.name );
};

var employeeSchema = new BaseSchema({
  title: String
});

employeeSchema.methods.speak = function() {
  console.log( "my name is %s, and my title is %s",this.name,this.title );
};

var groupSchema = new Schema({
  visitor: { "type": Schema.Types.ObjectId, "ref": "Person" },
  note: String,
  time: { "type": Date, "default": Date.now }
});

var Person    = mongoose.model( 'Person', personSchema ),
    Employee  = Person.discriminator( 'Employee', employeeSchema ),
    Group     = mongoose.model( 'Group', groupSchema );


async.waterfall(
  [
    // Clean data
    function(callback) {
      async.each([Person,Group],function(model,callback) {
        model.remove(callback);
      },callback);
    },

    // Add a person
    function(callback) {
      var person = new Person({ "name": "Bob" });
      person.save(function(err,person) {
        callback(err,person);
      });
    },

    // Add an employee
    function(person,callback) {
      var employee = new Employee({ "name": "Sarah", "title": "Manager" });
      employee.save(function(err,employee) {
        callback(err,person,employee);
      });
    },

    // Add person to group
    function(person,employee,callback) {
      var group = new Group({
        visitor: person
      });
      group.save(function(err) {
        callback(err,employee);
      });
    },

    // Add employee to group
    function(employee,callback) {
      var group = new Group({
        visitor: employee
      });
      group.save(function(err) {
        callback(err);
      });
    },

    // Get groups populated
    function(callback) {
      Group.find().populate('visitor').exec(function(err,group) {
        console.dir(group);
        group.forEach(function(member) {
          member.visitor.speak();
        });
        callback(err);
      });
    }

  ],
  function(err) {
    if (err) throw err;
    mongoose.disconnect();
  }
);

这里是非常基本的输出：

[ { _id: 55d06d984a4690ca1f0d73ed,
    visitor: { _id: 55d06d984a4690ca1f0d73eb, name: 'Bob', __v: 0 },
    __v: 0,
    time: Sun Aug 16 2015 21:01:44 GMT+1000 (AEST) },
  { _id: 55d06d984a4690ca1f0d73ee,
    visitor:
     { _id: 55d06d984a4690ca1f0d73ec,
       name: 'Sarah',
       title: 'Manager',
       __v: 0,
       __t: 'Employee' },
    __v: 0,
    time: Sun Aug 16 2015 21:01:44 GMT+1000 (AEST) } ]
my name is Bob
my name is Sarah, and my title is Manager

简而言之，我们这里有两种“类型”，即“Person”和“Employee”。 “Person”当然是每个人的基本类型，因此可以有一些基本属性，如果需要的话甚至可以有方法。 “Employee”继承自基“Person”，因此共享任何属性和方法，并且能够定义自己的。

在这里设置猫鼬模型时，这些是重要的行：

var Person    = mongoose.model( 'Person', personSchema ),
    Employee  = Person.discriminator( 'Employee', employeeSchema ),

请注意，“Employee”不使用标准的mongoose.model 构造函数，而是调用Person.discriminator。这做了一件特别的事情，实际上“Employee”实际上与“Person”模型共享，但有不同的信息告诉 mongoose 这实际上是一个“Employee”。

还要注意groupSchema中“visitor”的构造：

  visitor: { "type": Schema.Types.ObjectId, "ref": "Person" },

如前所述，“Person”和“Employee”实际上与“Person”共享相同的基本模型，但具有一些特定特征。所以这里的引用告诉猫鼬从这个模型中解析存储的 ObjectId 值。

当您致电.populate() 时，其美妙之处就显而易见了，如清单后面所述。随着这些引用中的每一个被解析，正确的对象类型被替换为那里的值。这一点在每个“访问者”对象上调用 .speak() 方法时变得很明显。

my name is Bob
my name is Sarah, and my title is Manager

您还可以获得其他很棒的东西，因为 mongoose 可以做一些事情，例如将“员工”视为模型并“自动”过滤掉任何查询中不是员工的任何对象。出于同样的原因，使用“Person”模型还将显示其中的所有类型（它们由“__t”属性和它的值来区分），因此您也可以在各种查询过程中利用它。

嵌入

因此，如果您不喜欢引用或通常只是希望将所有数据保留在“组”集合中，而不为其他“人员”数据单独收集而烦恼，那么这也是可能的。

您真正需要的只是对列表进行一些更改，特别是在“访问者”作为“混合”类型的架构定义中：

  visitor: Schema.Types.Mixed,

然后，由于所有数据都已经存在，而不是调用.populate()，您只需要进行一些手动“类型转换”，这实际上非常简单：

        group.forEach(function(member) {
          member.visitor = (member.visitor.hasOwnProperty("__t"))
            ? mongoose.model(member.visitor.__t)(member.visitor)
            : Person(member.visitor);
          member.visitor.speak();
        });

然后一切都可以与嵌入式数据“游泳”。

对于使用嵌入数据的完整列表：

var async     = require('async'),
    util      = require('util'),
    mongoose  = require('mongoose'),
    Schema    = mongoose.Schema;

mongoose.connect('mongodb://localhost/company');

function BaseSchema() {

  Schema.apply(this,arguments);

  this.add({
    name: String
  });

}

util.inherits(BaseSchema,Schema);

var personSchema = new BaseSchema();

personSchema.methods.speak = function() {
  console.log( "my name is %s",this.name );
};

var employeeSchema = new BaseSchema({
  title: String
});

employeeSchema.methods.speak = function() {
  console.log( "my name is %s and my title is %s",this.name,this.title );
};

var groupSchema = new Schema({
  visitor: Schema.Types.Mixed,
  note: String,
  time: { "type": Date, "default": Date.now }
});

var Person    = mongoose.model( 'Person', personSchema, null ),
    Employee  = Person.discriminator( 'Employee', employeeSchema, null ),
    Group     = mongoose.model( 'Group', groupSchema );


async.waterfall(
  [
    // Clean data
    function(callback) {
      async.each([Person,Group],function(model,callback) {
        model.remove(callback);
      },callback);
    },

    // Add a person
    function(callback) {
      var person = new Person({ "name": "Bob" });
      callback(null,person);
    },

    // Add an employee
    function(person,callback) {
      var employee = new Employee({ "name": "Sarah", "title": "Manager" });
      callback(null,person,employee);
    },

    // Add person to group
    function(person,employee,callback) {
      var group = new Group({
        visitor: person
      });
      group.save(function(err) {
        callback(err,employee);
      });
    },

    // Add employee to group
    function(employee,callback) {
      var group = new Group({
        visitor: employee
      });
      group.save(function(err) {
        callback(err);
      });
    },

    // Get groups populated
    function(callback) {
      Group.find().exec(function(err,group) {
        console.dir(group);
        group.forEach(function(member) {
          member.visitor = (member.visitor.hasOwnProperty("__t"))
            ? mongoose.model(member.visitor.__t)(member.visitor)
            : Person(member.visitor);
          member.visitor.speak();
        });
        callback(err);
      });
    }

  ],
  function(err) {
    if (err) throw err;
    mongoose.disconnect();
  }
);

这与上面的输出相同，并且创建的对象保留了方便的“鉴别器”信息。因此，您可以再次利用前面提到的内容。

【讨论】：