mongoose + 异步流程处理

万恶的callback

在nodejs入门的章节里我们已经讲了callback约定

  1. function (err, result) {
  2.     ...
  3. }

Node.js世界里，绝大部分函数都是遵守这个约定的。

举个典型的用户登录的例子吧，这是前面见过的

  1. UserSchema.statics.login = function(username, password, cb) {
  2.   this.findOne({
  3.     username: username
  4.   }, function (err, user) {
  5.     if (err || !user) {
  6.       if (err)
  7.         console.log(err);
  9.       return cb(err, {
  10.         code: -1,
  11.         msg : username + ' is not exist!'
  12.       });
  13.     }
  15.     bcrypt.compare(password, user.password, function(error, res) {
  16.       if (error) {
  17.         console.log(error);
  18.         return cb(err, {
  19.           code: -2,
  20.           msg : 'password is incorrect, please check it again!'
  21.         });
  22.       }
  24.       return cb(null, user);
  25.     });
  26.   });
  27. };

说明

  • login是有callback的
  • callback里遵守回调约定(err,result)

这里面findOne有一个回调，bcrypt.compare有一个回调，最后解决过通过login的回调传值回去，这还只是一个简单的逻辑，如果更复杂呢？

说callback是万恶的，其实一点也不冤枉，它其实是一种约定，但它却被滥用，导致给Node.js带来了长久以来很多人对Node.js的误解，但本身它只是一种形式，并不是最佳实践，所以持这种态度来看待Node.js是不公平的。

内置Promises：mpromise

Mongoose 异步操作，像 .save() 和 queries，返回 Promises/A+ conformant promises. This means that you can do things like MyModel.findOne({}).then() and yield MyModel.findOne({}).exec() (if you’re using co).
这就是说你可以做一些像MyModel.findOne({}).then() 和 yield MyModel.findOne({}).exec()（如果你在用co）

为了向后兼容，mongoose 4默认返回mpromise promise。

  1. var gnr = new Band({
  2.     name: "Guns N' Roses",
  3.     members: ['Axl', 'Slash']
  4. });
  6. var promise = gnr.save();
  7. assert.ok(promise instanceof require('mpromise'));
  9. promise.then(function (doc) {
  10.     assert.equal(doc.name, "Guns N' Roses");
  11. });

https://github.com/aheckmann/mpromise

Queries are not promises

mongoose查询不是promise。可是它有 yield 和 async/await 的 .then() 方法。如果你需要健全的promise，用.exec()方法。

  1. var query = Band.findOne({name: "Guns N' Roses"});
  2. assert.ok(!(query instanceof require('mpromise')));
  4. // A query is not a fully-fledged promise, but it does have a `.then()`.
  5. query.then(function (doc) {
  6.     // use doc
  7. });
  9. // `.exec()` gives you a fully-fledged promise
  10. var promise = query.exec();
  11. assert.ok(promise instanceof require('mpromise'));
  13. promise.then(function (doc) {
  14.     // use doc
  15. });

使用其他 Promises 库

在mongoose 4.1.0更新，在mpromise满足基本使用的情况下，高级用户可能想插入他们喜爱的ES6风格的Promise库如bluebird，或只是使用原生的ES6 promise。设置mongoose.Promise 给你喜欢的ES6风格的promise构造函数然后mongoose会使用它。

  1. var query = Band.findOne({name: "Guns N' Roses"});
  3. // Use native promises
  4. mongoose.Promise = global.Promise;
  5. assert.equal(query.exec().constructor, global.Promise);
  7. // Use bluebird
  8. mongoose.Promise = require('bluebird');
  9. assert.equal(query.exec().constructor, require('bluebird'));
  11. // Use q. Note that you **must** use `require('q').Promise`.
  12. mongoose.Promise = require('q').Promise;
  13. assert.ok(query.exec() instanceof require('q').makePromise);

MongoDB驱动的promise

mongoose.Promise属性设置mongoose使用promise。可是，这不影响底层MongoDB驱动。如果你使用底层驱动，例如Mondel.collection.db.insert()，你需要做点额外工作来改变底层promise库。注意，下面的代码假设mongoose >= 4.4.4。

  1. var uri = 'mongodb://localhost:27017/mongoose_test';
  2. // Use bluebird
  3. var options = { promiseLibrary: require('bluebird') };
  4. var db = mongoose.createConnection(uri, options);
  6. Band = db.model('band-promises', { name: String });
  8. db.on('open', function() {
  9.     assert.equal(Band.collection.findOne().constructor, require('bluebird'));
  10. });

bluebird promisifyAll

promisifyAll是bluebird提供的一个极其方便的api，可以把某个对象上的所有方法都变成返回promise对象方法，在Promise/A+规范里，只要返回promise对象就可以thenable组合完成业务逻辑组合。这是异步流程里比较好的方式。

如果Model里的方法都能返回Promise对象，那么这些方法就可以理解是乐高积木，在我们写业务逻辑时候，组合这些小模块就好了。

promisifyAll会把对象上的方法copy一份返回Promise对象的以“方法名Async”为名称的方法

原理

举例db/promisifyAll.js 

  1. var UserModel = {
  2.   create: function () {
  3.   },
  4.   retrieve: function () {
  5.   },
  6.   update: function () {
  7.   },
  8.   delete: function () {
  9.   }
  10. }
  12. var Promise = require("bluebird");
  14. // Promisify
  15. Promise.promisifyAll(UserModel);
  17. console.dir(UserModel)

执行

  1. $ node promisifyAll.js 
  2. { 
  3.   create: [Function],
  4.   retrieve: [Function],
  5.   update: [Function],
  6.   delete: [Function],
  7.   createAsync: [Function],
  8.   retrieveAsync: [Function],
  9.   updateAsync: [Function],
  10.   deleteAsync: [Function] 
  11. }

很明显，create被copy成了createAsync方法，其他亦然。也就是说[原来的方法]变成了[原来的方法Async]

下面看一下createAsync方法是否是返回Promise对象，按照co源码里判断promise的写法

  1. function isPromise(obj) {
  2.   return 'function' == typeof obj.then;
  3. }
  5. var is_promise = isPromise(UserModel.createAsync());
  6. console.log(is_promise)

返回是true，也就是说createAsync方法是返回的Promise对象。

具体实例

  1. var mongoose = require('mongoose');
  2. var Promise = require("bluebird");
  4. // 定义Schema
  5. UserSchema = new mongoose.Schema({
  6.   username: {// 真实姓名
  7.     type: String,
  8.     required: true
  9.   },
  10.   password: { // 密码
  11.     type: String,
  12.     required: true
  13.   }
  14. });
  16. // 定义Model
  17. var UserModel = mongoose.model('User', UserSchema);
  19. // Promisify
  20. Promise.promisifyAll(UserModel);
  21. Promise.promisifyAll(UserModel.prototype);
  23. // 暴露接口
  24. module.exports = UserModel;

步骤说明

步骤1：引入bluebird

  1. var Promise = require("bluebird");

步骤2：给某个对象应用promisifyAll

  1. // Promisify
  2. Promise.promisifyAll(UserModel);
  3. Promise.promisifyAll(UserModel.prototype);

测试代码

见db/promisify/test.js

  1. import test from 'ava';
  3. // 1、引入`mongoose connect`
  4. require('../connect');
  6. // 2、引入`User` Model
  7. const User = require('../user/promisify/user');
  9. // 3、定义`user` Entity
  10. const user = new User({
  11.   username: 'i5ting',
  12.   password: '0123456789'
  13. });
  15. test.cb('#thenable for default', t => {
  16.   user.save().then( (user) => {
  17.     // console.log(user)
  18.     t.pass()
  19.     t.end()
  20.   }).catch((err) => {
  21.     t.ifError(err);
  22.     t.fail();
  23.     t.end()
  24.   })
  25. });
  27. test.cb('#thenable for bluebird promisifyAll', t => {
  28.   user.saveAsync().then( (user) => {
  29.     // console.log(user)
  30.     t.pass()
  31.     t.end()
  32.   }).catch((err) => {
  33.     t.ifError(err);
  34.     t.fail();
  35.     t.end()
  36.   })
  37. });
  39. test.cb('#thenable for bluebird Async methods', t => {
  40.   user.saveAsync().then( (u) => {
  41.     return User.findByIdAndUpdateAsync( u._id, {'username' : 'aaaa'})
  42.   }).then((updated_result) => {
  43.     // console.log(updated_result)
  44.     return User.findOneAsync({'username' : 'aaaa'});
  45.   }).then((find_user) => {
  46.     // console.log(find_user)
  47.     t.pass()
  48.     t.end()
  49.   }).catch((err) => {
  50.     t.ifError(err);
  51.     t.fail();
  52.     t.end()
  53.   })
  54. });

总结：东西虽好，但不要滥用

凡是奇技淫巧都有特定场景的应用场景，虽好，但不要滥用。如果转换非常多，会有性能问题。但是在某些场景，比如模型操作上，还是非常方便、高效的。

generator in co

http://mongoosejs.com/docs/harmony.html

  1.     co(function*() {
  2.       var error;
  3.       var schema = new Schema({
  4.         description: {type: String, required: true}
  5.       });
  7.       var Breakfast = db.model('breakfast', schema, getCollectionName());
  9.       var goodBreakfast = new Breakfast({description: 'eggs & bacon'});
  11.       try {
  12.         yield goodBreakfast.save();
  13.       } catch (e) {
  14.         error = e;
  15.       }
  17.       assert.ifError(error);
  18.       var result;
  19.       try {
  20.         result = yield Breakfast.findOne().exec();
  21.       } catch (e) {
  22.         error = e;
  23.       }
  24.       assert.ifError(error);
  25.       assert.equal('eggs & bacon', result.description);
  27.       // Should cause a validation error because `description` is required
  28.       var badBreakfast = new Breakfast({});
  29.       try {
  30.         yield badBreakfast.save();
  31.       } catch (e) {
  32.         error = e;
  33.       }
  35.       assert.ok(error);
  36.       assert.ok(error instanceof ValidationError);
  38.       done();
  39.     })();

async/await

支持yield，其实就等于支持async/await了，但目前性能测试还不够好，所以暂时还不推荐使用。