Mongoose初使用总结

连接mongoose

mongoose连接数据库有两种方式
第一种：

'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',()=>{ //成功连接 })

第二种：

var mongoose = require('mongoose');

db = mongoose.createConnection('localhost', 'test'); var schema = new mongoose.Schema({ name: String }); var collectionName = 'kittens'; var M = db.model('Kitten', schema, collectionName); var silence = new M({ name: "Silence"}); silence.save(function(err){ });

mongoose.createConnection()和mongoose.connect()区别

首先，我们需要定义一个连接，如果你的app只用到一个数据库，你应该使用 mongoose.connect。如果你还需要连接其他数据库，使用mongoose.createConnection。
所有的 connect and createConnection 使用 mongodb:// URI, or the parameters host, database, port, options.等参数

var mongoose = require('mongoose');

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

一旦连接，Connection对象会触发open事件，如果你使用 mongoose.connect, Connection对象就是默认的 mongoose.connection，而使用 mongoose.createConnection 返回值就是 Connection.

Mongoose会缓存所有命令直到连接上数据库，这意味着你不必等待它连接MongoDB再定义 models，执行 queries 等。

Mongoose基本概念

Schema: 表定义模板
Model: 类似关系数据库表，封装成具有一些集合操作的对象
instance: 类似记录，由Model创建的实体，也具有影响数据库的操作

基本用法

//定义一个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); }) });

Schema

// from mongoose author
var mongoose = require('mongoose');
var Schema = mongoose.Schema;//引用出来，不需要每次调用 mongoose.Schema()这个丑陋的API. var blogSchema = new Schema({ title: String, author: String, //直接写法，会被转化成相应的SchemaType body: String, comments: [{ body: String, date: Date }], //定义SchemaType写法 date: { type: Date, default: Date.now }, hidden: Boolean, meta: { votes: Number, favs: Number } });

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

String
Number
Date
Buffer
Boolean
Mixed
ObjectId
Array

SchemaType

type属性指定SchemaType类型，不同的SchemaType类型还有其他不同的属性配置

var schema2 = new Schema({
  test: {
    type: String, lowercase: true // Always convert `test` to lowercase } });

这是所有类型公有的：

required: 必选验证器。
default: 默认值。Any或function，如果该值是一个函数，则该函数的返回值将用作默认值。
select: boolean值, 指定是否被投影
`validate: 验证器
get: get方法，using Object.defineProperty().
set: set方法 using Object.defineProperty().
alias: 别名。

其他类型特有属性官方API查找。

设置索引

这里设置索引分两种,一种设在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中设置, 这样分开能够增加可读性. 不过,
可以说，当应用启动的时候, ，Mongoose会自动为Schema中每个定义了索引的调用ensureIndex，确保生成索引.
并在所有的secureIndex调用成功或出现错误时，在 Model 上发出一个'index'事件。开发环境用这个很好, 但是建议在生产环境不要使用这个.使用下面的方法禁用ensureIndex。
通过将 Schema 的autoIndex选项设置为false或通过将选项config.autoIndex设置为false将连接全局设置为禁用此行为有可能严重拖慢查询或者创建速度,所以一般而言,我们需要将该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 }); //懒癌不推荐

// Will cause an error because mongodb has an _id index by default that
// is not sparse
animalSchema.index({ _id: 1 }, { sparse: true }); var Animal = mongoose.model('Animal', animalSchema); Animal.on('index', function(error) { // "_id index cannot be sparse" console.log(error.message); });

定义Schema.methods

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

实例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即可.

var schema = new Schema({ name: String });
schema.path('name').get(function (v) { return v + ' is my name'; }); schema.set('toObject', { getters: true }); var M = mongoose.model('Person', schema); var m = new M({ name: 'Max Headroom' }); console.log(m); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom is my name' }

toJSON：该是和toObject一样的使用. 通常用来把 documents 转化为Object. 但是, 需要显示使用toJSON()方法,

var schema = new Schema({ name: String });
schema.path('name').get(function (v) { return v + ' is my name'; }); schema.set('toJSON', { getters: true, virtuals: false }); var M = mongoose.model('Person', schema); var m = new M({ name: 'Max Headroom' }); console.log(m.toObject()); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom' } console.log(m.toJSON()); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom is my name' } // since we know toJSON is called whenever a js object is stringified: console.log(JSON.stringify(m)); // { "_id": "504e0cd7dd992d9be2f20b6f", "name": "Max Headroom is my name" }

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’.

想两边名称保持一致，可参考http://aiilive.blog.51cto.com/1925756/1405203

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' });

document的CRUD操作

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

document的创建

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! })

document的查询

Mongoose查找文档很容易，它支持MongoDB的丰富的查询语法。可以使用每个models find，findById，findOne或where 等静态方法进行查找文档。
事实上,在mongoose中,query数据提供了两种方式.

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

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

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

Tank.find({ size: 'small' }).where('createdDate').gt(oneYearAgo).exec(callback);

以下两种等价写法：

// With a JSON doc
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); // Using query builder Person. find({ occupation: /host/ }). where('name.last').equals('Ghost'). where('age').gt(17).lt(66). where('likes').in(['vaporizing', 'talking']). limit(10). sort('-occupation'). select('name occupation'). exec(callback);

Query Helpers

你能够添加 query helper functions,跟定义在Schema实例方法一样，但是返回query对象作为mongoose queries使用（说句白了就是封装mongoose查询方法）. Query helper methods 使你能够扩展mongoose's chainable query builder API.

animalSchema.query.byName = function(name) {
  return this.find({ name: new RegExp(name, 'i') }); }; var Animal = mongoose.model('Animal', animalSchema); Animal.find().byName('fido').exec(function(err, animals) { console.log(animals); });

上面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

另外还有一些游标集合的处理方法: 常用的就3个, limit,skip,sort.

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

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

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

query.skip(2);

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

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

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

document删除

reomve操作仅在通过回调时执行。要强制执行没有回调，您必须先调用remove（），然后使用exec（）方法执行它。
我们可以在document上执行remove方法也可以在Model上。

Model.find().remove({ name: 'Anne Murray' }, callback)
Model.remove({ name: 'Anne Murray' }, callback)
//没有添加回调情况
Model.find().remove({ name: 'Anne Murray' }).remove(callback)
Model.remove({ name: 'Anne Murray' }).exce(callback)

document更新

使用Model.update([(conditions, doc, [options], [callback])]
不返回更新对象到应用程序。如果要更新数据库中的单个文档并将其返回到应用程序，请改用findOneAndUpdate。

参数说明：

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)

new（使用findOneAndUpdate时才有参数）：bool - 如果为true，则返回修改后的文档而不是原始文件。默认为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是,用来指明更新的字段。

Validation

验证器在SchemaType中定义。
Validation 是一种中间件，Mongoose 触发 validation 同 a pre('save')钩子一样。
你能够手动触发 validation 通过doc.validate(callback) or doc.validateSync()。

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

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

内置验证器

Mongoose 有一些列内置验证器.

所有的SchemaTypes都有required验证器
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 } })

自定义验证器

如果内置验证器不够，您可以定义自定义验证器以满足您的需要。

// 创建验证器
function validator (val) { return val == 'something'; } new Schema({ name: { type: String, validate: validator }}); // 附带自定义错误信息 var custom = [validator, 'Uh oh, {PATH} does not equal "something".'] new Schema({ name: { type: String, validate: custom }}); //添加多验证器 var many = [ { validator: validator, msg: 'uh oh' } , { validator: anotherValidator, msg: 'failed' } ] new Schema({ name: { type: String, validate: many }}); // 直接通过SchemaType.validate方法定义验证器: var schema = new Schema({ name: 'string' }); schema.path('name').validate(validator, 'validation of `{PATH}` failed with value `{VALUE}`');

验证错误对象

验证失败后返回的错误包含一个包含实际ValidatorError对象的错误对象。每个ValidatorError都有kind，path，value和message属性。

  var toySchema = new Schema({
      color: String,
      name: String }); var Toy = db.model('Toy', toySchema); 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'); 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'); 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'); });

更新验证器

在Model.update那一节有个参数–runValidators. 还没有详细说. 这里, 展开一下. 实际上, validate一般只会应用在save上, 如果你想在update使用的话, 需要额外的trick，而runValidators就是这个trick.
Mongoose还支持update（）和findOneAndUpdate（）操作的验证。在Mongoose 4.x中，更新验证器默认关闭 - 您需要指定runValidators选项。

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

更多验证器用法请参考官方文档

population

ongodb 本来就是一门非关系型数据库。但有时候,我们又需要联合其他的table进行数据查找。 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: Number, ref: 'Person' }, title : String, fans : [{ type: Number, ref: 'Person' }] }); var Story = mongoose.model('Story', storySchema); var Person = mongoose.model('Person', personSchema);

Note: ObjectId, Number, String, and Buffer are valid for use as refs.

使用populate query方法进行关联

Story
.findOne({ title: 'Once upon a timex.' })
.populate('_creator')
.exec(function (err, story) { if (err) return handleError(err); console.log('The creator is %s', story._creator.name); // prints "The creator is Aaron" });

中间件

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

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

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

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

pre

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

串行

var schema = new Schema(..);
schema.pre('save', function(next) { // do stuff next(); //执行完毕，执行下一中间件 });

并行

var schema = new Schema(..);

// 设置第二参数为true，意味这是一个并行中间件
// as the second parameter if you want to use parallel middleware.
schema.pre('save', true, function(next, done) { // calling next kicks off the next middleware in parallel next(); setTimeout(done, 100); });

post

post会在指定事件后触发,就像事件监听器一样，post钩子没什么控制流程，即它是异步的。

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

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

// Takes 2 parameters: this is an asynchronous post hook
schema.post('save', function(doc, next) { setTimeout(function() { console.log('post1'); // Kick off the second post hook next(); }, 10); }); // Will not execute until the first middleware calls `next()` schema.post('save', function(doc, next) { console.log('post2'); next(); })