MONGOOSEDAO

DAO

DAO(Data Access Object)是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间，以便将低级别的数据访问逻辑与高级别的业务逻辑分离，为不同的数据库提供了一套统一的API。最开始是JavaEE 开发人员使用的，后来其他语言也争相模仿，

在核心J2EE模式中是这样介绍DAO模式的：为了建立一个健壮的J2EE应用，应该将所有对数据源的访问操作抽象封装在一个公共API中。用程序设计的语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口在逻辑上对应这个特定的数据存储。

简单点理解是

  1. DAO是对单一模型Model操作封装

什么是mongoosedao

mongoose是orm工具，提供了模型上的丰富的操作方法，但它的api可读性和操作易用性并不能满足我们dao的需求，我们需要有更简单的操作方法，于是mongoosedao应运而生。

https://github.com/moajs/mongoosedao

提供了很多使用api，他们都是模型上的方法，操作起来更加简便

  • create
  • delete = remove
  • deleteAll = removeAll
  • deleteById = removeById
  • getById
  • all = getAll = find({})
  • query = getByQuery = find
  • one = findOne
  • update
  • updateOne
  • updateById
  • pageByLastId
  • top(num) && first(num) = n(num) = latest(num)

  • count(cb) &* count({},cb)

    实现原理

    其实很简单，就是利用mongoose本身的一些特性，进行约定。

    1. function MongooseDao (Model){
    2. if(!Model){
    3.  throw new Error(Model + " is not valid, please check if it is a mongoose model!");
    4. }
    5. this.model = Model;
    6. this.pagesize = 20;
    7. }

通过把Model作为参数，构建dao对象。

别名,比如find我们把它绑定到dao上，可以叫find也可以叫query

  1. MongooseDao.prototype.query = MongooseDao.prototype.find = MongooseDao.prototype.getByQuery = function(query, cb) {
  2.   this.model.find(query, cb);
  3. };

比如count，有2种用法

查询全部总数

  1. User.count(cb)

按条件查询总数

  1. User.count({},cb)

具体实现代码

  1. MongooseDao.prototype.count = function() {
  2.   var query = {};
  3.   var cb;
  4.   //count({a:1},cb)
  5.   if (arguments.length == 2) {
  6.     query   = arguments[0];
  7.     cb      = arguments[1];
  8.   }else{
  9.     //default : count(cb)
  10.     cb      = arguments[0];
  11.   }
  12.   this.model.count(query, cb);
  13. };

更新依然

  1. // way1: conditions, update , cb
  2. // way2: conditions, update ,options, cb
  3. MongooseDao.prototype.update = function() {
  4.   var conditions, update ,options, cb;
  6.   var _options;
  7.   if (arguments.length == 3) {
  8.     _options = {}
  9.     conditions = arguments[0];
  10.     update = arguments[1];
  11.     cb = arguments[2];
  12.   }else if(arguments.length == 4) {
  13.     conditions = arguments[0];
  14.     update = arguments[1];
  15.     _options = arguments[2];
  16.     cb = arguments[3];
  17.   }else{
  18.     throw new Error("MongooseDao.prototype.update param is not valid!")
  19.   }
  22.   var opt = { multi: true };
  23.   _extend(opt, _options);
  25.   this.model.update(conditions, update, opt, cb);
  26. };

用法

定义模型

  1. var TopModel = mongoose.model('TopModel', TopSchema); 
  2. var TopModelDao = new MongooseDao(TopModel);
  3. module.exports = TopModelDao;

用法

  1. require('./db');
  3. var User = require('./User');
  5. User.create({"username":"sss","password":"password"},function(err, user){
  6.   console.log(user);
  7. });
  9. User.delete({"username":"sss"},function(err, user){
  10.   console.log(user);
  11. });

pagination

latest = top = first = n

获取指定前20条数

  1.   Top.top(function(err, tops){
  2.     if(err){
  3.       console.dir(err);
  4.     }
  6.     // console.dir(tops.length);
  7.     assert.equal(tops.length == 20, true);
  8.     done();
  9.   });

获取指定前xx条数

  1.   Top.top(30 ,function(err, tops){
  2.     if(err){
  3.       console.dir(err);
  4.     }
  6.     // console.dir(tops.length);
  7.     assert.equal(tops.length == 30, true);
  8.     done();
  9.   });

根据查询条件获取指定前xx条数

  1.   Top.top(30, {}, function(err, tops){
  2.     if(err){
  3.       console.dir(err);
  4.     }
  6.     // console.dir(tops.length);
  7.     assert.equal(tops.length == 30, true);
  8.     done();
  9.   });

根据查询条件获取指定前xx条数,支持排序

  1.   // sort by "field" ascending and "test" descending
  2.   var query = {};
  3.   var sort = {field: 'asc', test: -1 }；
  4.   Top.top(30, query, sort , function(err, tops){
  5.     if(err){
  6.       console.dir(err);
  7.     }
  9.     // console.dir(tops.length);
  10.     assert.equal(tops.length == 30, true);
  11.     done();
  12.   });

更改pagesize

  1.   Top.pagesize = 25;
  2.   Top.top(function(err, tops){
  3.     if(err){
  4.       console.dir(err);
  5.     }
  7.     // console.dir(tops.length);
  8.     assert.equal(tops.length == 25, true);
  9.     done();
  10.   });

pageByLastId

根据id直接返回，长度看Top.pagesize 

  1. Top.pageByLastId(one._id, function(err, new_tops){

根据id直接返回，长度看第二个参数，下面的例子是50

  1. Top.pageByLastId(one._id, 50, function(err, new_tops){

根据id直接返回，长度看第二个参数，下面的例子是50，不带带有排序条件

  1. Top.pageByLastId(one._id, 100, {"username" : "fixture-user-41"}, function(err, new_tops){

根据id直接返回，长度看第二个参数，下面的例子是50，带有排序条件，created_at是升序

  1. Top.pageByLastId(one._id, 100, {"username" : "fixture-user-41"}, {created_at:'asc'}, function(err, new_tops){

mongoosedao + promisifyAll

  1. var mongoose    = require('mongoose');
  2. var Schema      = mongoose.Schema;
  3. var MongooseDao = require('mongoosedao');
  5. var contactSchema = new Schema(
  6.   {
  7.     "name":"String",
  8.     "address":"String",
  9.     "tel":"String",
  10.     "owner_id":"String",
  11.     "created_at": {
  12.       type: Date,
  13.       "default": Date.now()
  14.     }
  15.   }
  16. );
  19. var Contact = mongoose.model('Contact', contactSchema);
  20. var ContactDao = new MongooseDao(Contact);
  21. var Promise = require("bluebird");
  23. Promise.promisifyAll(Contact);
  24. Promise.promisifyAll(Contact.prototype);
  26. Promise.promisifyAll(ContactDao);
  27. module.exports = ContactDao;

注意，为了方便直接使用模型，给模型和dao都增加了promisifyAll方法，核心代码如下

  1. var Promise = require("bluebird");
  3. Promise.promisifyAll(Contact);
  4. Promise.promisifyAll(Contact.prototype);
  6. Promise.promisifyAll(ContactDao);

如何扩展mongoosedao

User.model is a mongoose model. You can do all as mongoose model。

more features

  • statics
  • methods
  • pre or post hook
  • aggregation

比如直接扩展方法

  1. var mongoose = require('mongoose');
  2. var Schema = mongoose.Schema;
  3. var Promise = require('bluebird');
  5. var User = require('../app/models/user');
  7. User.schema.statics.find_by_openid = function(openid, cb) {
  8.   console.log('find_by_openid...')
  9. };
  11. // 此处必须要重置一下model
  12. User = mongoose.model('User', User.schema);
  14. var MongooseDao       = require('mongoosedao');
  16. var UserDao = new MongooseDao(Test);
  18. UserDao.model.find_by_openid({}, function(err,docs){
  19.   // console.dir(docs);
  20.   process.exit();
  21. });

当然我们更推荐的是在model定义上直接加

  1. var mongoose = require('mongoose');
  2. var Schema = mongoose.Schema;
  5. UserSchema = new Schema({
  6.   username: {
  7.     type: String,
  8.     required: true,
  9.     index: {
  10.       unique: true
  11.     }
  12.   },
  13.   password: {
  14.     type: String,
  15.     required: true
  16.   },
  17.   avatar: String,
  18.   address: String,
  19.   created_at: {
  20.     type: Date,
  21.     "default": Date.now
  22.   }
  23. });
  25. UserSchema.methods.find_by_name = function(cb) {
  26.   return this.model('UserModel').find({
  27.     username: this.username
  28.   }, cb);
  29. };
  31. UserSchema.methods.is_exist = function(cb) {
  32.   var query;
  33.   query = {
  34.     username: this.username,
  35.     password: this.password
  36.   };
  37.   return this.model('UserModel').findOne(query, cb);
  38. };
  40. UserSchema.statics.delete_by_name = function(name, cb_succ, cb_fail) {};
  42. var UserModel = mongoose.model('UserModel', UserSchema);
  44. var MongooseDao = require('../../');
  47. var MeetingDao = new MongooseDao(UserModel);
  49. module.exports = MeetingDao;

只要mongoose支持的，使用mongoosedao都可以完成，甚至更好。

总结

mongoosedao是对mongoose操作的约定，提供了更方便的api封装而已，结合bluebird的promisifyAll可以非常好的满足我们日常的业务需求。