深入淺出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:pass@localhost:port/database', { config: { autoIndex: false } }); //真心推薦 // or mongoose.createConnection('mongodb://user:pass@localhost: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 的值還是不變 不過可以使用虛擬屬性,進行操作.