黄月月鸟飞

突然发现好久没写blog了，从今天开始继续坚持写博客，下午捣鼓了一下小应用，使用老赵的jscex给mongoose添加了Async 同步方法，感觉还不错，至少对我来说相当节省开发效率。

给mongoose添加jscex的方法很简单，只需要使用老赵的 ”Jscex异步增强模块“进行异步操作绑定即可，什么是”Jscex异步增强模块“在此我就不缀述了，感兴趣的同学直接访问 Jscex异步增强模块 即可，这里仅贴出mongoose的异步操作绑定代码，代码比较简单，就不说明了。

var Jscex = require("jscex");

require("jscex-jit").init(Jscex);
require("jscex-async").init(Jscex);
require("./jscex-async-powerpack").init(Jscex);

module.exports = Jscex;

上面的代码是用于加载找姐夫的异步增强模块，我事先用npm安装了jscex，命令如下” npm install jscex jscex-jit jscex-async”，详细看赵姐夫的 jscex说明

var mongoose = require('mongoose'),
	Jscex = require('../plugins/jscex-start'),
	Model = mongoose.Model;

var Async = Jscex.Async;
var Task = Async.Task;
var Jscexify = Async.Jscexify;

var addSugarMethods = function(methods , obj){
	for(var i = 0 , len = methods.length; i < len ; i++){
		if(obj[methods[i]])
			obj[methods[i] + 'Async'] = Jscexify.fromStandard(obj[methods[i]]);
	}
}

module.exports = {
	init : function(){
		addSugarMethods(['find','remove'],Model.prototype);
	},
	model : function(name ,schema){
		mongoose.model(name, schema);
		var methods = ['find','remove','findById','findOne','count','distinct','create','update'];
		var model = mongoose.model(name);
		addSugarMethods(methods,model);
	}
}

上面的代码就是加语法糖的代码了，下面以node-club源码里的User 对象做个例子

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var modelAsync = require('./modelAsync');

var UserSchema = new Schema({
	//用户昵称
	name: {
		type: String,
		index: true
	},
	//用户登录名称:唯一
	loginname: {
		type: String
	},
	//登录密码
	pass: {
		type: String
	},
	//邮箱
	email: {
		type: String
	},
	//个人主页
	url: {
		type: String
	},
	//住址
	location: {
		type: String
	},
	//个性签名
	signature: {
		type: String
	},
	//个人简介
	profile: {
		type: String
	},
	//微薄
	weibo: {
		type: String
	},
	//头像
	avatar: {
		type: String
	},
	//被关注的人数
	follower_count: {
		type: Number,
		default: 0
	},
	//关注的人数
	following_count: {
		type: Number,
		default: 0
	},
	//创建时间
	create_at: {
		type: Date,
		default: Date.now
	},
	//更新时间
	update_at: {
		type: Date,
		default: Date.now
	},
	//是否活动状态
	active: {
		type: Boolean,
		default: true
	}
});

modelAsync.model('User', UserSchema);

上面的modelAsync即是前面异步绑定的模块，好，开始测试

var mongoose = require('mongoose'),
	config= require('../config').config,
	modelAsync = require('./modelAsync');

modelAsync.init();

mongoose.connect(config.db, function(err){
	if(err){
		console.log('connect to db error: ' + err.message);
		process.exit(1);
	}
});

// models
require('./user');

exports.User = mongoose.model('User');

上面代码取自node-club里的源码，至此就可以用同步的写法去获取数据了，测试代码如下，很简明易懂吧，当然如果你不喜欢这样的写法也可以继续使用异步的方式

var models      = require('../../models'),
	User = models.User,
	should = require('should'),
	Jscex = require('../../plugins/jscex-start');

module.exports = {

  'test updating documents async': function () {

  		var saveUserAsync = eval(Jscex.compile("async", function (user) {
		    $await(user.saveAsync());
		    var _user = $await(User.findAsync({ _id : user._id }));
		   	should.exist(_user);
		    _user.should.have.length(1);
		}));

	    var user = new User();

  		user.name      = 'flyhuang';
  		user.loginname = 'hpf1908';
  		user.pass      = '123456';
  		user.email     = 'hpf1908@gmail.com';

	    var task = saveUserAsync(user);

	    task.addEventListener("complete", function (t) {
		    if (t && t.error) {
		    	should.strictEqual(t.error, null);
		        console.log(t.error);
		        process.exit(1);
		    } else {
		    	console.log('done');
		        process.exit();
		    }
		});

		task.start();
  	},
  	'test delete documents async' : function(){

  		var removeUserAsync = eval(Jscex.compile("async", function (user) {
  			$await(user.saveAsync());
		    $await(User.removeAsync({ name : user.name }));
		    var _user = $await(User.findAsync({ name : user.name }));
		   	_user.should.be.empty;
		}));

		var user = new User();

  		user.name      = 'flyhuang';
  		user.loginname = 'hpf1908';
  		user.pass      = '123456';
  		user.email     = 'hpf1908@gmail.com';

	    var task = removeUserAsync(user);

	    task.addEventListener("complete", function (t) {
		    if (t && t.error) {
		    	should.strictEqual(t.error, null);
		        console.log(t.error);
		        process.exit(1);
		    } else {
		    	console.log('done');
		        process.exit();
		    }
		});

		task.start();
  	}
}

再贴一个用异步写法的例子，以作对比

var models      = require('../../models'),
	User = models.User,
	should = require('should');

module.exports = {

  'test updating documents': function () {

  		var user = new User();

  		user.name      = 'flyhuang';
  		user.loginname = 'hpf1908';
  		user.pass      = '123456';
  		user.email     = 'hpf1908@gmail.com';

	    user.save(function (err) {
	    	should.strictEqual(err, null);
	    	User.find({ _id : user._id },function(err , user){
	  			should.strictEqual(err, null);
	  			should.exist(user);
	  			user.should.have.length(1);

	  			console.log('done');
	  		});
	    });
  	},
  	'test delete documents' : function(){
  		var user = new User();

  		user.name      = 'flyhuang';
  		user.loginname = 'hpf1908';
  		user.pass      = '123456';
  		user.email     = 'hpf1908@gmail.com';

  		user.save(function (err) {
  			should.strictEqual(err, null);
	  		User.remove({ name : 'flyhuang' },function(err ){
	  			should.strictEqual(err, null);
	  			User.find({ name : 'flyhuang'},function(err , user){
		  			should.strictEqual(err, null);
		  			user.should.be.empty;
		  			console.log('done');
		  		});
	  		});
  		});
  	}
}