深入浅出mongoose

Posted 2021-01-13 binguo666

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了深入浅出mongoose相关的知识，希望对你有一定的参考价值。

深入浅出mongoose

mongoose是nodeJS提供连接 mongodb的一个库. 此外还有mongoskin, mongodb(mongodb官方出品). 本人,还是比较青睐mongoose的, 因为他遵循的是一种, 模板式方法, 能够对你输入的数据进行自动处理. 有兴趣的同学可以去Mongoose官网看看.

初入mongoose

install mongoose

I’ve said that. 使用mongoose你需要有 nodeJS和mongodb数据库. 这两个东西, 前端宝宝们应该很清楚了》下载mongoose:

npm install mongoose --save

connect mongoose

下载好数据库之后,我们来碰碰运气, 看你能不能连接上database. 首先,打开你的mongodb;

mongod;  //这里我已经将mongodb放在环境变量中了

数据库成功打开后: 在js文件中写入:

‘use strict‘;

const mongoose = require(‘mongoose‘);

mongoose.connect(‘mongodb://localhost:27017/test‘);
const con = mongoose.connection;
con.on(‘error‘, console.error.bind(console, ‘连接数据库失败‘));
con.once(‘open‘,()=>{
    //成功连接
})

(其实,懂得童鞋,你只要copy就行了.) OK,运气好的同学,此刻嘴角扬起45°的微笑. 运气差的同学, 出门左转google. 简单连接mongoose后,我们来看一看mongoose的基本构造吧.

understand mongoose

mongoose实际上,可以说是Oracle和mongodb的一个混合产物,但归根接地还是mongodb的. 这里我要祭出,我珍藏很久的对比图. 熟悉其他数据库的同学应该能很快明白的.

Oracle	MongoDB	Mongoose
数据库实例(database instance)	MongoDB实例	Mongoose
模式(schema)	数据库(database)	mongoose
表(table)	集合(collection)	模板(Schema)+模型(Model)
行(row)	文档(document)	实例(instance)
rowid	_id	_id
Join	DBRef	DBRef

通过上面的阐述,我们大概能知道了在Mongoose里面有哪几个基本概念.

Schema: 相当于一个数据库的模板. Model可以通过mongoose.model 集成其基本属性内容. 当然也可以选择不继承.
Model: 基本文档数据的父类,通过集成Schema定义的基本方法和属性得到相关的内容.
instance: 这就是实实在在的数据了. 通过 new Model()初始化得到.

他们各自间是怎样的关系呢？下图可以清晰的说明, 以上3中实际上就是一个继承一个得到最后的数据.

技术分享图片

我们先看一个demo吧:

‘use strict‘;

const mongoose = require(‘mongoose‘);


mongoose.connect(‘mongodb://localhost:27017/test‘);
const con = mongoose.connection;
con.on(‘error‘, console.error.bind(console, ‘连接数据库失败‘));
con.once(‘open‘,()=>{
    //定义一个schema
    let Schema = mongoose.Schema({
        category:String,
        name:String
    });
    Schema.methods.eat = function(){
        console.log("I‘ve eatten one "+this.name);
    }
    //继承一个schema
    let Model = mongoose.model("fruit",Schema);
    //生成一个document
    let apple = new Model({
        category:‘apple‘,
        name:‘apple‘
    });
    //存放数据
    apple.save((err,apple)=>{
        if(err) return console.log(err);
        apple.eat();
        //查找数据
        Model.find({name:‘apple‘},(err,data)=>{
            console.log(data);
        })
    });
})

到这里, 实际上, mongoose我们已经就学会了. 剩下就是看一看官方文档的API–CRUD相关操作. 如果,大家觉得意犹未尽的话,可以继续看下面的深入浅出. 而且, 下面会附上实际应用中, mongoose的写法.

深入浅出mongoose

这里,我们根据上面的3个概念深入的展开一下.

Schema

这实际上是,mongoose中最重要的一个theroy. schema 是用来定义 documents的基本字段和集合的. 在mongoose中,提供了Schema的类。我们可以通过实例化他, 来实现创建 Schema的效果. 而不需要每次调用 mongoose.Schema()这个丑陋的API.

// from mongoose author
var mongoose = require(‘mongoose‘);
var Schema = mongoose.Schema;

var blogSchema = new Schema({
  title:  String,
  author: String,
  body:   String,
  comments: [{ body: String, date: Date }],
  date: { type: Date, default: Date.now },
  hidden: Boolean,
  meta: {
    votes: Number,
    favs:  Number
  }
});

Schema 之所以能够定义documents, 是因为他可以限制你输入的字段及其类型. mongoose支持的基本类型有:

String
Number
Date
Buffer
Boolean
Mixed
ObjectId
Array

其中, Mixed和ObjectId是mongoose中特有的,ObjectId实际上就是**_id**的一个映射. 同样,mongoose里面有着和所有大众数据库一样的东西. 索引 – indexs

mongoose 设置索引

这里设置索引分两种,一种设在Schema filed, 另外一种设在 Schema.index 里.

//在field 设置
var animalSchema = new Schema({
  name: String,
  type: String,
  tags: { type: [String], index: true } 
});
//在Schema.index中设置.
animalSchema.index({ name: 1, type: -1 }); 

//1 表示正序, -1 表示逆序

实际上,两者效果是一样的. 看每个人的喜好了. 不过推荐直接在Schema level中设置, 这样分开能够增加可读性. 不过,官方给出了一个建议, 因为在创建字段时, 数据库会自动根据自动排序(ensureIndex). 有可能严重拖慢查询或者创建速度,所以一般而言,我们需要将该option 关闭.

mongoose.connect(‘mongodb://user:[email protected]:port/database‘, { config: { autoIndex: false } });  //真心推荐
// or  
mongoose.createConnection(‘mongodb://user:[email protected]:port/database‘, { config: { autoIndex: false } });  //不推荐
// or
animalSchema.set(‘autoIndex‘, false);  //推荐
// or
new Schema({..}, { autoIndex: false }); //懒癌不推荐

另外, Schema 另一大特色就是其methods. 我们可以通过定义其methods,访问到实际上的所有内容.

定义Schema.methods

使用的方法很简单,就是使用 .methods即可.

// 定义一个schema
var freshSchema = new Schema({ name: String, type: String });

// 添加一个fn. 
animalSchema.methods.findSimilarTypes = function (cb) {
  //这里的this指的是具体document上的this
  return this.model(‘Animal‘).find({ type: this.type }, cb);
}
// 实际上,我们可以通过schema绑定上,数据库操作的所有方法.
// 该method实际上是绑定在 实例的 doc上的

定义完methods和property之后, 就到了生成Model的阶段了.

实例Model

这里同样很简单,只需要 mongoose.model() 即可.

//生成,model 类. 实际上就相当于我们的一个collection
var Animal = mongoose.model(‘Animal‘, animalSchema);
var dog = new Animal({ type: ‘dog‘ });

但是, 这里有个问题. 我们在Schema.methods.fn 上定义的方法,只能在 new Model() 得到的实例中才能访问. 那如果我们想,直接在Model上调用相关的查询或者删除呢？

绑定Model方法

同样很简单,使用 statics 即可.

// 给model添加一个findByName方法
animalSchema.statics.findByName = function (name, cb) {
  //这里的this 指的就是Model
  return this.find({ name: new RegExp(name, ‘i‘) }, cb);
}

var Animal = mongoose.model(‘Animal‘, animalSchema);
Animal.findByName(‘fido‘, function (err, animals) {
  console.log(animals);
});

Mongoose 还有一个super featrue-- virtual property 该属性是直接设置在Schema上的. 但是,需要注意的是,VR 并不会真正的存放在db中. 他只是一个提取数据的方法.

//schema基本内容
var personSchema = new Schema({
  name: {
    first: String,
    last: String
  }
});

// 生成Model
var Person = mongoose.model(‘Person‘, personSchema);

//现在我们有个需求,即,需要将first和last结合输出.
//一种方法是,使用methods来实现
//schema 添加方法
personSchema.methods.getName = function(){
    return this.first+" "+this.last;
}

// 生成一个doc
var bad = new Person({
    name: { first: ‘jimmy‘, last: ‘Gay‘ }
});

//调用
bad.getName();

但是,像这样,仅仅这是为了获取一个属性, 实际上完全可以使用虚拟属性来实现.

//schema 添加虚拟属性
personSchema.virtual(‘fullName‘).get(function(){
    return this.first+" "+this.last;
})
//调用
bad.fullName;  //和上面的方法的结果是完全一致的

而且,经过测试, 使用fn实现的返回,比VR 要慢几十倍. 一下是测试结果:

    console.time(1);
    bad.getName();
    console.timeEnd(1);
    console.time(2);
    bad.fullName;
    console.timeEnd(2);
    
    //结果为:
    1: 4.323ms;  //method
    2: 0.253ms  // VR

最后再补充一下,Schema中初始化的相关参数.

Schema参数在 new Schema([options]) 中,我们需要设置一些相关的参数.

safe: 用来设置安全模式. 实际上,就是定义入库时数据的写入限制. 比如写入时限等.

 //使用安全模式. 表示在写入操作时,如果发生错误,也需要返回信息.
 var safe = true;
new Schema({ .. }, { safe: safe });

// 自定义安全模式. w为写入的大小范围. wtimeout设置写入时限. 如果超出10s则返回error
var safe = { w: "majority", wtimeout: 10000 };
new Schema({ .. }, { safe: safe });

toObject: 用来表示在提取数据的时候, 把documents 内容转化为Object内容输出. 一般而言只需要设置getters为true即可.

schema.set(‘toObject‘, { getters: true });
var M = mongoose.model(‘Person‘, schema);
var m = new M({ name: ‘Max Headroom‘ });
//实际打印出来的就是一个Object类型
console.log(m); // { _id: 504e0cd7dd992d9be2f20b6f, name: ‘Max Headroom is my name‘ }

toJSON：该是和toObject一样的使用. 通常用来把 documents 转化为Object. 但是, 需要显示使用toJSON()方法,否则,不会起作用. 实际上,没什么卵用…

看一下总结图谱: 技术分享图片

看完schema之后,我们需要了解一下 model的内容.

Model

实际上,Model才是操作数据库最直接的一块内容. 我们所有的CRUD就是围绕着Model 展开的. ok. 还记得,我们是怎样创建一个model的吗？

model的创建

model的创建实际上就是方法的copy. 将schema上的方法,copy到model上. 只是copy的位置不一样, 一部分在prototype上, 一部分在constructor中.

//from mongoosejs
var schema = new mongoose.Schema({ name: ‘string‘, size: ‘string‘ });
var Tank = mongoose.model(‘Tank‘, schema);

这里,我们一定要搞清楚一个东西. 实际上, mongoose.model里面定义的第一个参数,比如’Tank’, 并不是数据库中的, collection. 他只是collection的单数形式, 实际上在db中的collection是’Tanks’.

ok, 我们现在已经有了一个基本的Model. 但并没有什么x用. 接下来, 正式到了 dry goods(干货) 时间.

model 的子文档操作这个就厉害了. 本来mongodb是没有关系的. 但是, mongoose提供了children字段. 让我们能够轻松的在表间建立关系. 现在,我们来创建一个子域:

var childSchema = new Schema({ name: ‘string‘ });

var parentSchema = new Schema({
  children: [childSchema]   //指明sub-doc的schema
});
//在创建中指明doc
var Parent = mongoose.model(‘Parent‘, parentSchema);
var parent = new Parent({ children: [{ name: ‘Matt‘ }, { name: ‘Sarah‘ }] })
parent.children[0].name = ‘Matthew‘;
parent.save(callback);

现在, 我们就已经创建了3个table. 一个parent 包含了两个child 另外,如果我们想要查询指定的doc。则可以使用 id()方法.

var doc = parent.children.id(id);

子文档的CRUD, 实际上就是数组的操作, 比如push,unshift,remove,pop,shift等

parent.children.push({ name: ‘Liesl‘ });

mongoose还给移除提供了另外一个方法–remove:

var doc = parent.children.id(id).remove();

如果你忘记添加子文档的话，可以在外围添加, 但是字段必须在Schema中指定

var newdoc = parent.children.create({ name: ‘Aaron‘ });

model的CRUD操作

model的创建关于model的创建,有两种方法, 一种是使用实例创建,另外一种是使用Model类创建.

var Tank = mongoose.model(‘Tank‘, yourSchema);

var small = new Tank({ size: ‘small‘ });
//使用实例创建
small.save(function (err) {
  if (err) return handleError(err);
  // saved!
})

//使用Model类创建
Tank.create({ size: ‘small‘ }, function (err, small) {
  if (err) return handleError(err);
  // saved!
})

上面已经完美的介绍创建的方法了. 另外,官方给出一个提醒: 由于mongoose, 会自身连接数据库并断开. 如果你手动连接, 则创建model的方式需要改变.

// 自己并没有打开连接:
//注意,这里只是连接,并没有创建connection
mongoose.connect(‘mongodb://localhost:27017/test‘); 

//手动创建连接:
var connection = mongoose.createConnection(‘mongodb://localhost:27017/test‘);
var Tank = connection.model(‘Tank‘, yourSchema);

然后, 下面的API还是一样的. 实际上,我们一般常用的写法为:

const mongoose = require(‘mongoose‘);
const Schema = mongoose.Schema;
//设置连接位置
mongoose.connect(‘mongodb://localhost:27017/test‘);
var schema = new mongoose.Schema({ name: ‘string‘, size: ‘string‘ });
var Tank = mongoose.model(‘Tank‘, schema);
var small = new Tank({ size: ‘small‘ });
//使用实例创建
small.save(function (err) {
  if (err) return handleError(err);
  console.log(‘创建成功‘);
})

这样,就不用自己去手动管连接的问题了. 如果你,在后面想手动添加字段的话,可以使用.set方法.

// 一个key/valye
doc.set(path, value)
//很多key/value
doc.set({
    path  : value,
    path2 : {
       path  : value
    }
})

model的query model的查找主要提供了以下的API,给我们进行操作. find, findById, findOne, or where 在mongodb中, query返回的数据格式一般都是为JSON的. 这点需要注意.

事实上,在mongoose中,query数据提供了两种方式.

callback: 使用回调函数, 即, query会立即执行,然后返回到回调函数中.

Person.findOne({ ‘name.last‘: ‘Ghost‘ }, ‘name occupation‘, function (err, person) {
  if (err) return handleError(err);
 // get data
})

query: 使用查询方法,返回的对象. 该对象是一个Promise, 所以可以使用 chain 进行调用.最后必须使用exec(cb)传入回调进行处理. cb 是一个套路, 第一个参数永远是err. 第二个就是返回的数据。

Person.
  find({
    occupation: /host/,
    ‘name.last‘: ‘Ghost‘,
    age: { $gt: 17, $lt: 66 },
    likes: { $in: [‘vaporizing‘, ‘talking‘] }
  }).
  limit(10).
  sort({ occupation: -1 }).
  select({ name: 1, occupation: 1 }).
  exec(callback);
  
//如果没有查询到,则返回[] (空数组)
// 如果你使用findOne, 没有的话则会返回 null

童鞋, 你觉得我会推荐哪种呢？

上面4个API, 3个使用方式都是一样的, 另外一个不同的是where. 他一样是用来进行query. 只是,写法和find系列略有不同.

where简介 where的API为: Model.where(path, [val]) path实际上就是字段, 第二个参数.val表示可以用来指定,path = val的数据内容, 你也可以不写, 交给后面进行筛选. 看一下对比demo吧:

User.find({age: {$gte: 21, $lte: 65}}, callback);
//等价于:
User.where(‘age‘).gte(21).lte(65).exec(callback);

从上面的query中,我们可以看到有许多fn, 比如gte,lte,$gte,$lte. 这些是db提供给我们用来查询的快捷函数. 我们可以参考, mongoose给的参考: query Helper fn 这里,我们简要的了解下,基本的快捷函数.

name	effect
select	添加需要显示的字段,需要的字段在字段后加上:1,不需要的加上0;<br/>query.select({ a: 1, b: 0 }); //显示a字段, 隐藏b字段<br/>不能和distinct方法一起使用
distinct	用来筛选不重复的值或者字段<br/>distinct(field). //筛选指定不重复字段的数据
$lt,$lte,$gt,$gte.	分别对应: <,<=,>,>=. 该字段是用在condition中的.如果,你想要链式调用,则需要使用<br/>lt,lte,ge,gte.<br/>eg:<br/> model.find({num:{$gt:12}},cb)<br/>model.where(‘num’).gt(12).exec(cb)
$in	查询包含键值的文档,<br/>model.find({name:{$in:[“jimmy”,“sam”]}}) //相当于匹配 jimmy或者sam
$nin	返回不匹配查询条件文档,都是指定数组类型<br/>model.find({name:{$nin:[“jimmy”,“sam”]}})
$ne	表示不包含指定值<br/>model.find({name:{$ne:“sam”}})
$or	表示或查询<br/>model.find({$or:[{ color: ‘red’ }, { status: ‘emergency’ }]})
$exits	表示键值是否存在;<br/>model.find({name:{$exits:true}})
$all	通常用来匹配数组里面的键值,匹配多个值(同时具有)<br/>$all:[“apple”,“banana”,“peach”]}
$size	用来查询数组的长度值<br/>model.find({name:{$size:3}}); 匹配name的数组长度为3
$slice	用来获取数组字段的内容:<br/>query.slice(‘comments’, 5)

ok~ 这上面就是比较常用的快捷函数. 另外还有一些游标集合的处理方法: 常用的就3个, limit,skip,sort.

**limit:**用来获取限定长度的内容.

query.limit(20); //只返回前20个内容

skip: 返回，跳过指定doc后的值.

query.skip(2);

sort: 用来设置根据指定字段排序. 可以设置为1:升序, -1:降序.

query.sort({name:1,age:-1});

实际上, 关于query,我们需要了解的也就差不多了.

我们接下来,来看一下remove. mongoose remove 操作

官方提供的API,就是remove. 同样,移除的效果,我们可以使用两种方式实现。一是回调函数, 二是, 链式调用.

 Model.find().remove({ name: ‘Anne Murray‘ }).remove(fn);
 //或者直接添加回调
 Model.find().remove({ name: ‘Anne Murray‘ },cb)

另外,我们可以直接在Model上调用. 因为remove也是Schema定义的statics方法. 而且, remove返回一个Promise对象

product.remove().then(function (product) {
   ...
});
//或者直接传入回调
Tank.remove({ size: ‘large‘ }, function (err) {
  if (err) return handleError(err);
  // removed!
});

最后,我们再看一下 update. 然后mongoose就基本结束了 update操作: 这里,我只说一下API就好. 因为update 比起上面来说,还是比较简单的. Model.update(conditions, doc, [options], [callback])

conditions: 就是query. 通过query获取到指定doc
doc: 就是用来替换doc内容的值.
options: 这块需要说一下.
- safe (boolean) 是否开启安全模式 (default for true)
- upsert (boolean) 如果没有匹配到内容,是否自动创建 ( default for false)
- multi (boolean) 如果有多个doc,匹配到,是否一起更改 ( default for false)
- strict (boolean) 使用严格模式(default for false)
- overwrite (boolean) 匹配到指定doc,是否覆盖 (default for false)
- runValidators (boolean): 表示是否用来启用验证. 实际上,你首先需要写一个验证. 关于如果书写,验证大家可以参考下文, validate篇(default for false)

Model.update({age:18}, { $set: { name: ‘jason borne‘ }}, {multi:true}, function (err, raw) {
  if (err) return handleError(err);
  console.log(‘raw 就是mongodb返回的更改状态的falg ‘, raw);
  //比如: { ok: 1, nModified: 2, n: 2 }
});

其中的$set是,用来指明更新的字段.另外,mongoose还提供了一个:findByIdAndUpdate(id,doc[,options][,callback]); 方法. 关于mongoose的更新helper 函数. 童鞋们可以参考一下.mongoose官方文档.

validation

说完了,mongoose的body之后. 我们接着来看一下,官方给mongoose穿上的漂亮的衣服. 其中一件,比较吸引人的是–validation. 在你save数据之前, 你可以对数据进行一些列的validation. 来防止某天你傻不拉几的把数据完整性给破坏了. mongoose贴心的提供了几个built-in的验证函数.

required: 表示必填字段.

new Schema({
 name: {
    type:String,
    required:[true,"name 是必须的"] //第二个参数是错误提示信息
 }
})

min,max: 用来给Number类型的数据设置限制.

 var breakfastSchema = new Schema({
      eggs: {
        type: Number,
        min: [6, ‘Too few eggs‘],
        max: 12
      }
});

enum,match,maxlength,minlength: 这些验证是给string类型的. enum 就是枚举,表示该属性值,只能出席那那些. match是用来匹配正则表达式的. maxlength&minlength 显示字符串的长度.

new Schema({
    drink: {
        type: String,
        enum: [‘Coffee‘, ‘Tea‘]
      },
     food:{
        type: String,
        match:/^a/,
        maxlength:12,
        minlength:6
    }
})

mongoose提供的helper fn就是这几种, 如果你想定制化验证. 可以使用custom validation.

new Schema({
 phone: {
        type: String,
        validate: {
          validator: function(data) {
            return /d{3}-d{3}-d{4}/.test(data);
          },
          message: ‘{VALUE} is not a valid phone number!‘ //VALUE代表phone存放的值
        },
        required: [true, ‘User phone number required‘]
      }
})

另外,还可以额外添加验证.

  var toySchema = new Schema({
      color: String,
      name: String
    });

   var validator = function (value) {
      return /blue|green|white|red|orange|periwinkle/i.test(value);
    };
    toySchema.path(‘color‘).validate(validator,
      ‘Color `{VALUE}` not valid‘, ‘Invalid color‘);

现在,我们已经设置了validation. 但是你不启用,一样没有什么卵用. 实际上, 我们也可以把validation当做一个中间件使用. mongoose 提供了两种调用方式. 一种是内置调用, 当你使用.save方法时,他会首先执行一次存储方法.

cat.save(function(error) {
//自动执行,validation
});

另外一种是,手动验证–指定validate方法.

//上面已经设置好user的字段内容.
  user.validate(function(error) {
    //error 就是验证不通过返回的错误信息
     assert.equal(error.errors[‘phone‘].message,
        ‘555.0123 is not a valid phone number!‘);
    });
});

事实上, 在validate时, 错误的返回信息有以下4个字段: kind, path, value, and message;

kind: 用来表示验证设置的第二个参数. 一般不用

phone: {
        type: String,
        validate: {
          validator: function(data) {
            return /d{3}-d{3}-d{4}/.test(data);
          },
          message: ‘{VALUE} is not a valid phone number!‘, //VALUE代表phone存放的值
          kind: "invalid phone"
        }
})

path: 就是字段名
value: 你设置的错误内容
message: 提示错误信息看一个整体demo吧:

 var validator = function (value) {
      return /blue|green|white|red|orange|periwinkle/i.test(value);
    };
    Toy.schema.path(‘color‘).validate(validator,
      ‘Color `{VALUE}` not valid‘, ‘Invalid color‘); //设置了message && kind

    var toy = new Toy({ color: ‘grease‘});

    toy.save(function (err) {
      // err is our ValidationError object
      // err.errors.color is a ValidatorError object
      assert.equal(err.errors.color.message, ‘Color `grease` not valid‘); //返回message
      assert.equal(err.errors.color.kind, ‘Invalid color‘);
      assert.equal(err.errors.color.path, ‘color‘);
      assert.equal(err.errors.color.value, ‘grease‘);
      assert.equal(err.name, ‘ValidationError‘);
      //访问color 也可以直接上 errors["color"]进行访问.
    });

在Model.update那一节有个参数–runValidators. 还没有详细说. 这里, 展开一下. 实际上, validate一般只会应用在save上, 如果你想在update使用的话, 需要额外的trick，而runValidators就是这个trick.

var opts = { runValidators: true };
    Test.update({}, update, opts, function(error) {  //额外开启runValidators的验证
      // There will never be a validation error here
    });

我们来看一下基本总结吧: 技术分享图片

population

originally, mongodb 本来就是一门非关系型数据库。但有时候,我们又需要联合其他的table进行数据查找。这时候, 一般的做法就是实现两次查询，效率我就呵呵了.
此时, mongoose 说了一句: 麻麻, 我已经都把脏活帮你做好了. 感动~ 有木有~ 这就是mongoose提供的 population. 用来连接多表数据查询. 一般而言, 我们只要提供某一个collection的_id , 就可以实现完美的联合查询. population 用到的关键字是: ref 用来指明外联的数据库的名字. 一般,我们需要在schema中就定义好.

var mongoose = require(‘mongoose‘)
  , Schema = mongoose.Schema
  
var personSchema = Schema({
  _id     : Number,
  name    : String,
  age     : Number,
  stories : [{ type: Schema.Types.ObjectId, ref: ‘Story‘ }]
});

var storySchema = Schema({
  _creator : { type: Schema.Types.ObjectId, ref: ‘Person‘ },
  title    : String
});

这里就指明了, 外联数据表的应用关系 personSchema <stories> By _id => Story storySchema <_creator> By _id => Person 实际上, 就是通过_id的相互索引即可. 这里需要说明的是, _id 应该是某个具体model的id.

我们来看一下, 接下来应该如何利用population实现外联查询.

const sam = new Person({
    name: ‘sam‘,
    _id: 1,
    age: 18,
    stories: []
});
sam.save((err,sam)=>{
    if(err) return err;
    let story = new Story({
        _creator:sam._id,
        title:"喜剧之王"
    })
})

Story.findOne({title:"喜剧之王"}).populate(‘_creator‘).exec((err,story)=>{
    if(err)console.log(err);
    console.log(story._creator.name);
})
//使用populate来指定,外联查询的字段, 而且该值必须是_id才行

现在es6时代的来临, generator , async/await 盛行. 也带来另外一种书写方式–middleware. 在mongoose也有这个hook, 给我们使用. (说实话, 有点像AOP)

mongoose && middleware

mongoose里的中间件,有两个, 一个是pre, 一个是post.

pre: 在指定方法执行之前绑定。中间件的状态分为 parallel和series.
post: 相当于事件监听的绑定

这里需要说明一下, 中间件一般仅仅只能限于在几个方法中使用. (但感觉就已经是全部了)

doc 方法上: init,validate,save,remove;
model方法上: count,find,findOne,findOneAndRemove,findOneAndUpdate,update

pre

我们来看一下,pre中间件是如何绑定的.

// series执行, 串行
var schema = new Schema(..);
schema.pre(‘save‘, function(next) {
 // exe some operations
 this.model.
  next();  //  这里的next()相当于间执行权给下一个pre
});

在你调用 model.save方法时, 他会自动执行pre. 如果你想并行执行中间件, 可以设置为:

schema.pre(‘save‘, true, function(next, done) {
  // 并行执行下一个中间件
  next();
});

post

相当于绑定啦~ post会在指定事件后触发

schema.post(‘save‘, function(doc) {
 //在save完成后 触发.
  console.log(‘%s has been saved‘, doc._id);
});

当save方法调用时, 便会触发post绑定的save事件. 如果你绑定了多个post。则需要指定一下中间件顺序.

schema.post(‘save‘, function(doc, next) {
  setTimeout(function() {
    console.log(‘post1‘);
    next();
  }, 10);
});

schema.post(‘save‘, function(doc, next) {
  console.log(‘post2‘);
  next();
});

实际上,post触发的时间为:

var schema = new Schema(..);
schema.post(‘save‘, function (doc) {
  console.log(‘this fired after a document was saved‘);
});

var Model = mongoose.model(‘Model‘, schema);

var m = new Model(..);
m.save(function (err) {
  console.log(‘this fires after the `post` hook‘);
});

另外,在post和find中, 是不能直接修改doc上的属性的. 即,像下面一样的,没有效果

articleSchema.post(‘find‘,function(docs){
    docs[1].date = 1
})
docs[1].date 的值还是不变

不过可以使用虚拟属性,进行操作.

转载来源 https://www.cnblogs.com/chris-oil/p/9142795.html

以上是关于深入浅出mongoose的主要内容，如果未能解决你的问题，请参考以下文章

深入浅出mongoose

「游戏引擎浅入浅出」4.3 片段着色器

mongoose 给文档的子数组的头部插入数据