Mongoose - 在 NodeJs 中优雅地建立 MongoDb 对象模型

[JZLeung]

Mongoose - 在 NodeJs 中优雅地建立 MongoDb 对象模型

在 NodeJs 中写 MongoDb 的校验，构造和业务逻辑简直是一种拖累。这就是为什么我们写了 Mongoose。

什么是 MongoDb 和 Mongoose

MongoDb

MongoDB is an open-source document database that provides high performance, high availability, and automatic scaling.

MongoDb 是一个开源的文档数据库，可提供高性能，高可用性和自动缩放。

MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。

MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。

Mongoose

Mongoose provides a straight-forward, schema-based solution to model your application data. It includes built-in type casting, validation, query building, business logic hooks and more, out of the box.

Mongoose 为你的应用程序数据提供了一个直接的，基于模型的解决方案。他包括内置的类型转换，校验，建立查询，业务逻辑的钩子等。

Mongoose是一个提供了MongoDB地相映射的Node.js库，它在Node.js中与ORM（Object Relational Mapping）有着类似的接口。如果你不熟悉ORM或者Mongoose中的Object Data Mapping（ODM），意思是Mongoose将数据库中的数据转换为JavaScript对象以供你在应用中使用。

为什么使用 Mongoose

Let’s face it, writing MongoDB validation, casting and business logic boilerplate is a drag

安装和使用 Mongoose

1. 安装
   $ npm install mongoose --save-dev

2. 使用
   $ touch index.js

   在 index.js 文件中引入 Mongoose ，并连接数据库

   var mongoose = require('mongoose'); mongoose.connect('mongodb://localhost/myblog');//连接上 myblog 数据库
   

开始使用 Mongoose 操作 MongoDb

注：本文默认已经搭好 Nodejs 和 MongoDb 环境，若未搭建环境，请移步至 -> 还在编写当中

假设我们在构建一个博客，需要将博文存储至数据库中。
而每一篇博文的结构如下：

{
    "title": "标题",
    "author": "作者",
    "date": "时间",
    "comments": "评论",
    "tags": "标签",
    "body": "正文"
}

OK, Go！

Mongoose 中的 Schema 和 Model

在使用 Mongoose 前，先了解一下 Mongoose 中的 Schema 和 Model。

• Schema
  在使用 Mongoose 前，先了解一下 Mongoose 中的 Schema 和 Model。

  Everything in Mongoose starts with a Schema. Each schema maps to a MongoDB collection and defines the shape of the documents within that collection.

  在 Mongoose 中，所有东西都从一个 Schema 开始。每一个 schema 都映射到一个 MongoDb 的集合，并定义了该集合中的文档的形式。

  定义一个 Schema：

  var Schema = mongoose.Schema;
  var userSchema = new Schema({
      name: String,
      pass: String,
      email: String,
      createTime: Date,
      lastLogin: Date
  });

  Schema 中的每一个键都定义了一个文档的一个属性。在上面的例子中，我们定义了用户名 name ，它会被映射为 String 的 Schema 类

  型，注册时间 createTime 会被映射为 Date 的 Schema 类型。

  允许的 Schema 类型有：（了解更多）

  • String
  • Number
  • Date
  • Buffer
  • Boolean
  • Mixed
  • ObjectId
  • Array

  用法：

  • 自定义方法
    模型的实例都是一个个的文档，文档中自带许多方法。同时，我们也可以定义我们自己的方法。

    var userSchema = new Schema({
        name: String,
        pass: String,
        email: String,
        createTime: Date,
        lastLogin: Date，
        type: String
    });
    //根据该用户的类型区查找该类型下的所有用户
    userSchema.methods.findUsersByType = function(name, cb){
        return this.find({type: this.type}, cb);
    }
    //新建模型
    var User = mongoose.model('User', userSchema);
    //使用
    var newUser = new User({...});
    newUser.findUsersByType(function(err, users){
        err && return console.error(err);
        console.log(users);
    })

    这样就向 User 的实例添加了一个自定义的方法。

  • 静态方法
    同样的，向模型中添加自定义方法也是很简单。

    userSchema.statics.findUsersByName = function(name, cb){
        return this.find({name: new RegExp(name, "ig")}, cb);
    }
    //使用
    User.findUsersByName('leung', function(err, users){
        err && return console.error(err);
        console.log(users);
    })

  • 查询辅助
    可以自定义一个查询的辅助函数，它和实体的方法类似，但是供 Mongoose 查询使用。

    userSchema.query.byName = function(name){
        return this.find({name: new RegExp(name, "ig")});
    }
    //使用
    userSchema.find().byName('leung').exec(function(err, users){
        err && return console.error(err);
        console.log(users);
    })

  • 索引
    MongoDb 支持第二个索引，在使用 Mongoose 的时候，可以在定义 Schema 的时候定义索引。

    //定义方法1
    var userSchema = new Schema({
        name: String,
        pass: String,
        email: String,
        createTime: {type: Date, index: true},
        lastLogin: {type: Date, index: true},
        type: String
    });
    //定义方法2
    userSchema.index({ createTime: 1, lastLogin: -1 });

    Mongoose 会在程序启动的时候，对于每个定义了索引的字段自动调用 ensureIndex 函数。当在不需要这些索引的时候，可以使用下列 4 种方式关闭索引。

    mongoose.connect('mongodb://user:pass@localhost:port/database', { config: { autoIndex: false } });
    // or
    mongoose.createConnection('mongodb://user:pass@localhost:port/database', { config: { autoIndex: false } });
    // or
    userSchema.set('autoIndex', false);
    // or
    new Schema({..}, { autoIndex: false });

  • 虚拟字段
    虚拟字段可以让你很方便的在文档中存取，但是不会写入数据库中。getter 方法在格式化或者合并字段的时候很有用，而 setter 方法则在反格式化或者时将多个值合并的时候有用。

    var personSchema = new Schema({
        name:{
            firstName: String,
            lastName: String
        }
    });
    var Person = mongoose.model('Person', personSchema);
    //定义虚拟字段 fullName
    personSchema.virtual('name.fullName').get(function(){
        console.log(this);
        return this.name.firstName + ' ' + this.name.lastName;
    })
    var me = new Person({name: {firstName: 'zhong', lastName: 'Lueng'}});
    console.log(me);
    console.log(me.name.fullName) //zhong Lueng

    虚拟字段的 setter 方法会在其他校验前使用，因此，即使字段时必须的，虚拟字段也会正常执行。

    只用非虚拟字段才可以在查询或者字段选择中使用。

  • 配置项
    Schema 有许多可配置的配置项，可以在新建 Schema 时或者直接设置。

    new Schema({..}, options);
    //or
    var schema = new Schema({..});
    schema.set(option, value);

    有效的配置项：

    • autoIndex
    • capped
    • collection
    • emitIndexErrors
    • id
    • _id
    • minimize
    • read
    • safe
    • shardKey
    • strict
    • toJSON
    • toObject
    • typeKey
    • validateBeforeSave
    • versionKey
    • skipVersioning
    • timestamps

• Model
  在 Mongoose 中，模型是通过已定义的 Schema 生成，这些模型的实例可以保存并检索数据库中的文档。数据库中的所有文档都是通过模型来创建和检索。

  • 创建文档
    文档是模型的实例，创建文档和将其保存到数据库中是非常简单的：

    var animalSchema = new Schema({
        type: String
    });
    var Animal = mongoose.model('Animal', animalSchema);
    var cat = new Animal({type: 'cat'});
    cat.save((err, doc) =>{
        err && console.error(err);
        console.log('doc is saved');//saved
    });
    // or
    Animal.create({type: 'cat'}, (err, doc) =>{
        err && console.error(err);
        //saved!
    })

  • 查询文档
    在 Mongoose 中查询文档是很方便的，同时支持 MongoDb 原生语法，模型中有许多内置的静态函数： find , where , findById , findOne 等等， 也支持链式调用。

    Animal.find({type: 'dog'}).where('age').gt(2).limit(10).exec();

  • 移除文档
    每个模型都有一个默认的移除方法，可以移除所有符合搜索条件的文档。

    Animal.remove({type: 'dongbeihu'}, (err, res){
        err && console.error(err);
        //removed!
    })

  • 更新文档
    每个模型都有他自己的更新方法，供更新数据库中所有符合条件的文档，同时不返回任何东西。

    如果需要更新单个文档，并且返回更新后的文档，请使用 findOneAndUpdate

下面可开始使用 Mongoose 来操作 MongoDb 数据库了。

1. 创建博文的 Schema

   var Schema = mongoose.Schema;
   var blogSchema = new Schema({
       title: String,          //标题
       author: String,         //作者
       body: String,           //正文
       comments: [{            //评论
           author: String,
           date: Date,
           body: String
       }],
       date: {type: Date, default: Date.now},  //发布时间
       isDelete: Boolean,                        //是否删除
       tags: [{type: String}]                  //标签
   }, {collection: 'blog'});   //选择 blog 集合

2. 创建一个 Blog 模型
   创建了一个模型之后，我们就可以通过模型去创建新的文档或者去操作数据库。

   var Blog = mongoose.model('Blog', blogSchema);

3. 创建一个新的实体对象
   这里的所有数据都是通过 Mockjs 进行模拟。详情移步至 Mockjs 官网
   使用 mockjs 模拟真实数据

   var Mock = require('mockjs');
   var Random = Mock.Random;
   exports.getBlog = function(){
       var blog = {
           title: Random.ctitle(3,10),         //随机生成一个长度3-10之间的中文标题
           author: Random.cword(2,3),          //随机生成一个长度2-3之间的中文单词
           body: Random.cparagraph(1,3),       //随机生成1-3段中文段落
           comments: [],
           date: Random.datetime('yyyy-MM-dd HH:mm'),  //随机生成一个时间点
           tags: []
       }
       var length =~~(Math.random()*10) +5;
       for (var i = 0; i < length; i++) {
           blog.comments.push(Mock.mock({
                       author: Random.cword(2,3),      //随机生成一条评论的作者名字
                       body: Random.cparagraph(1,3),   //随机生成一条评论的内容
                       date: Random.datetime('yyyy-MM-dd HH:mm')   //随机生成评论的时间点
                   }))
       }
       var length2 =~~(Math.random()*4) +2;
       for (var i = 0; i < length2; i++) {             //随机加入几个标签
           var tag = Random.pick(['nodejs','js','html','css','java','php','python']);
           if(blog.tags.indexOf(tag) == -1) blog.tags.push(tag)
       }
       return blog;
   }

   生成一个 blog 实体对象

   var newBlog = require('./blog')；        //导入随机生成数据的模块
   var blogObj = newBlog.getBlog();
   var blog = new Blog(blogObj)  //将随机生成的数据转换成为 blog 模型的实体。
   //生成实体对象的另一种方法.
   //此方法相当于创建了一个实体并写入数据库，再返回一个 promise 对象。
   //var blog2 = Blog.create(blogObj);

4. 数据库的 CRUD

   • create
     基于实体对象: Entity.save(callback);

     Example:

     var blogObj = newBlog.getBlog();
     var blog = new Blog(blogObj)
     blog.save((err, doc) => {
         if(err) return console.error(err);
         console.log(doc);
     })
     //{title: '...', author: '...'}

     结果：

     

     基于模型： Model.create(Obj, callback)

     Example:

     Blog.create(blogObj, (err, doc) => {
         if(err) return console.error(err);
         console.log(doc);
     })
     //{title: '...', author: '...'}

     结果：

     

   • delete
     基于实体对象：Entity.remove(cb)

     基于模型：Model.remove(query, cb)

   • update
     基于实体对象：Entity.update(cb)

     Example:

     var blog = new Blog(blogObj);
     blog.save((err, doc) => {   //先添加新的博文
         if(err) console.error(err);
         console.log('Entity.save()');
         console.log(doc);
         //通过实体直接更新博文
         blog.update({$set: {date: new Date(), title: 'Update From Mongoose'}}, (err2, doc) => {
             if(err2) return console.error(err2);
             console.log(doc);
         })
     })

     结果：
     
     更新后在 Mongobooster 中的数据
     
     基于模型：

     Model.update(query, docs, options, cb)

     参数：

     • query：查询条件。
     • docs：需要更新的数据。
     • options：配置项。
     • cb：回调。
       返回：

     <Qeury> this

     其中，配置项中有效的配置如下：

     • safe (boolean) safe mode (defaults to value set in schema (true))
     • upsert (boolean) whether to create the doc if it doesn’t match (false)
     • multi (boolean) whether multiple documents should be updated (false)
     • runValidators: if true, runs update validators on this command. Update validators validate the update operation against the model’s schema.
     • setDefaultsOnInsert: if this and upsert are true, mongoose will apply the defaults specified in the model’s schema if a new document is created. This option only works on MongoDB * >= 2.4 because it relies on MongoDB’s $setOnInsert operator.
     • strict (boolean) overrides the strict option for this update
     • overwrite (boolean) disables update-only mode, allowing you to overwrite the doc (false)
     • context (string) if set to ‘query’ and runValidators is on, this will refer to the query in custom validator functions that update * validation runs. Does nothing if runValidators is false.

     只有传入 callback 时，所有的更新操作才会被执行

     Example：

     //以下操作均不会执行
     var q = Blog.where({title: /del/g}).update({$set: {comments: []}});
     //等同于
     //var q = where({title: /del/g}).update({comments: []});
     //下面三条命令均会执行更新操作。
     //q.exec()
     //q.update(true)
     var q = Blog.where({title: /del/g}).update({$set: {comments: []}}, (err) => {
         //executes
     });
     //将文档重写为空文档
     var q = Blog.where({ _id: id }).setOptions({ overwrite: true })
     q.update({ }, callback); // executes
     //or
     //var q = Blog.update({_id: id}, {}, {overwrite: true}, callback);
     //将所有博文的创建日期设置为今天
     Blog.where()
      .setOptions({ multi: true })
      .update({ $set: { date: new Date() }}, callback)
     //or
     //Blog.update({}, { $set: { date: new Date() }}, { multi: true }, callback);

     批量更新结果：
     

   • read(query)
     find 操作包含了许多查询的操作，在这里只介绍最常用的几种查询方法，具体的可以查阅官网的 API Guide

     • $where (注意前面的 $)
       可以传入一个 javascript 函数或者表达式作为查询条件。

     用法：$where(js)

     //在数据库中找出作者名字长度为 2 且评论大于 10 条的博文：
     Blog
     .$where('this.comments.length >= 10 && this.author.length === 3')
     //.$where(function(){return this.comments.length >= 10 && this.author.length === 3;})
     .select('title author commentSize')
     .find((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：
     

     • where
       指定一个查询字段,供后续的链式调用.字段可以是字符串,也可以时一个完整的查询对象。

     用法：where(path, val)，path 可以是字符串或是对象

     //查找评论数大于8条,且标题含有叫字的博文
     Blog
     .where('commentSize').gte(8)
     //.where({'commentSize':{gte: 8}})
     .where('title', /叫/g)
     .select('title author commentSize')
     .find((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：
     

   • all
     指定一个 all 的查询条件。all 的使用方法可以查阅 MongoDb 官方文档

     用法： all([path], val),当只传递一个参数时，查询字段已经在 where 中指定。

     //查询出同时含有 html 和 js 标签的博文
     Blog
     // .where('tags').all(['html', 'js'])
     .find().all('tags', ['html', 'js'])
     .select('title author tags')
     .find((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：
     

   • and
     指定一个 and 的查询条件。

     用法：and(array)

     //查找出标题带有叫字，且含有 js 标签的博文
     Blog.find()
     .and([{title: /叫/g}, {tags: 'js'}])
     .select('title author tags')
     .find((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：
     

   • count
     返回符合指定条件的文档个数。

     用法：count(query, callback)

     //查找出标题带有叫字，且含有 js 标签的博文
     Blog.find()
     .and([{title: /叫/g}, {tags: 'js'}])
     .select('title author tags')
     .count((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：1

   • limit
     指定返回查询条数。

     用法：limit(Number)。

   • or / nor
     指定一组查询条件，只要符合/不符合其中一个条件即可。

     用法：or(array) / nor(array)

     //查询所有标签包含 js, 或者标题有“叫”字的博文
     Blog.find()
     .or([{title: /叫/g}, {tags: 'css'}])
     .select('title author tags')
     .find((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：
     

     //查询所有标签不包含 js或者标题不含有“叫”字的博文
     Blog.find()
     .nor([{title: /叫/g}, {tags: 'js'}])
     .select('title author tags')
     .find((err, docs)=>{
         if(err) return console.error(err);
         console.log(docs);
     })

     查询结果：
     

   • slice
     返回符合指定条件的文档个数。

     用法：slice([path], value)

     //查出所有的博文，并显示每个博文的第一个标签。
     Blog
     .where('tags').slice(1)
     .select('title')
     .limit(4)
     .exec((err, doc) => {
         console.log(doc);
     })

     查询结果：
     

   • sort
     设定排序规则。

     用法：sort(arg).参数可以是对象，可以是字符串。

     //查出所有的博文，并按照标题排序。
     Blog.find()
     .sort('title')
     //.sort({title: 1})     //传入对象参数
     //.sort({title: -1})    //传入对象参数，标题倒叙
     //.sort('-title')       //传入对象字符串，标题倒叙
     .limit(4)
     .exec((err, doc) => {
         console.log(doc);
     })

     查询结果：
     

5. validate
   Mongoose 中，在定义 Schema 的时候，允许用户自定义字段的校验规则。当在 Schema 中定义校验规则的时候，需要遵守下列规则：

   • 校验规则需要在 Schema 中定义。
   • 校验会在 save 操作前调用。
   • 可以通过 doc.validate(callback) 和 doc.validateSync() 手动校验。
   • 未定义校验规则的字段将不会校验，除非是 required 必要字段。
   • 校验时异步递归的，当使用 Model.save 时，子文档的校验规则将会立即调用，有错误时，执行的 Model.save 会接收到错误。
   • 校验时自定义的。
     普通的校验定义：

   var personSchema = new Schema({
   name:{
       type: String,
       validate:{
           validator: function(value){
               //只能以字母开头，只能包含英文数字下划线。
               return /^[a-zA-Z][a-zA-Z0-9_]*$/.test(value);
           },
           message: '{VALUE} is not a valid username. It must begin with a letter.'
       },
       required: [true, 'Username is required']
   },
   phone: {
       type: String,
       validate: {
       validator: function(v) {
           //11位电话号码
           return /\d{11}/.test(v);
           },
           message: '{VALUE} is not a valid phone number!'
       },
       required: [true, 'User phone number required']
   },
   gender:{
       type: String,
       enum: {
           //只能是男女
           values: ['female', 'male'],
           message: '{VALUE} is not a valid gender'
       },s
   }
   },{collection: 'person'})
   var Person = mongoose.model('Person', personSchema);
   //测试数据
   var one = new Person({
       name: '123',
       phone:'11111',
       gender:' male'
   })

   我们使用 one.validateSync() 对数据进行验证，其验证结果如下：
   
   Mongoose 中内置的验证如下：

   • 所有的 Schema 都有 required 校验规则，必要校验器会调用 Schema 的 chenckRequired() 函数去校验该字段的值是否符合规则。
   • Number 类型有 min 和 max。
   • String 类型有 enum, minlength, maxlength, match的校验器。

   • required：必填校验。
     可以传入的参数为：boolean[，String]。当只传 true 或者 false 时，用于定义该字段是否为必填；当传入第二个参数 String 时，该信息作为校验失败的错误提示语。
   • enum：枚举类型校验。
     接受参数类型为：Array/ Object。当类型为 Array 时，指定该字段的值必须在该数组中；当传入类型为 Object 时，可以定义两个键值队：values 和 message，values 的类型为 Array，指定字段的值必须在数组 values 中，message 指定校验失败的错误提示语。
   • validator：校验的对象。
     该对象包含 2 个键值队：
     • validate 可以是正则表达式，也可以是一个函数。
     • message 则是错误信息提示语。
   • min ,max：对数字类型的进行大小校验。第二个参数可以为字符串，作为错误提示语。
   • minlength ,maxlength：对字符串类型的进行长度校验。第二个参数可以为字符串，作为错误提示语。
   • match：接受一个正则表达式进行验证。第二个参数可以为字符串，作为错误提示语。
   • trim：字符串在校验时，是否去除前后字符串。默认为 false。

使用 Mongoose 的自动校验功能，可以省下许多校验操作。

以前，我们直接使用 Mongodb 去操作数据，每次读取操作都要打开，关闭数据库，但是当网页刷新/访问过于频繁时，就会出现数据库来不及关闭，又开始新的查询，就可能会出现 error。

现在，我们使用 Mongoose，打开数据库的连接之后，db 就会一直处于连接状态，不需要在访问时才打开连接，操作完后关闭连接，Error 也不再出现了。而且，代码的易读性也提高了不少。