Mongoose轻松搞定MongoDB，不要回调！

时间 2019-12-18

标签 mongoose 轻松搞定 mongodb 不要栏目 MongoDB 繁體版

原文原文链接

MEAN开发栈中使用MongoDB的时候，与之配对的ORM最好的选择就是Mongoose了。本文就和你们一块儿探讨一下如何使用Mongoose来实现MongoDB的增删改查。javascript

为了能使文中的例子更加生动，咱们会实现一个对于用户的增删改查的RESTful API。html

Mongoose简介

mongoose是一个nodejs下，专门基于no-sql数据库mongodb的ORM框架。咱们可使用mongoose轻松实现对于mongodb的操做。要是用mongoose首先要在项目中添加这个框架：java

$ npm install mongoose --save

注意，这里假设你已经安装了MongoDB。若是尚未，那么请参考这里下载，参考这里安装，并建立第一个数据库。node

在项目中引用mongoose：web

var mongoose = require('mongoose');

链接到已有数据库：sql

var url = 'mongodb://localhost/yourappdatabase';
mongoose.createConnection(url);

链接到数据库后就要处理里面的数据了。mongodb

定义一个Model

在处理增删改查之前，咱们先看看mongoose的Model。这些Model就表明了MongoDB库里面的Document（MongoDB术语，至关于Sql数据库的表），之后的增删改查都要经过这个Model实现。数据库

mongoose的Schema是用来定义document的属性的。Schema中也能够定义Methods。npm

首先定义一个model：json

var mongoose = require('mongoose');

var Schema = mongoose.Schema;

var userSchema = new Schema({
    name: String,
    username: { type: String, required: true, unique: true },
    password: { type: String, required: true },
    admin: Boolean,
    location: String,
    meta: {
    age: Number,
    website: String
    },
    created_at: Date,
    updated_at: Date
});

var User = mongoose.model('User', userSchema);

module.exports = User;

首先使用Schema定义一个userSchema，做为以后model里包含的字段和字段的类型使用。若是schema里包含了其余的对象，那么就把这个对象定义在meta属性内。

在mongoose的Schema里给字段指定类型时可用的类型有：

String
Number
Date
Buffer
Boolean
Mixed
ObjectId
Array

以后用mongoose.model类建立Model。咱们还能够在这里作更多，好比定义一个给用户密码加密的方法（稍后讲到）。

自定义方法

var mongoose = require('mongoose');

var Schema = mongoose.Schema;

var userSchema = new Schema({
    name: String,
    username: { type: String, required: true, unique: true },
    password: { type: String, required: true },
    admin: Boolean,
    location: String,
    meta: {
    age: Number,
    website: String
    },
    created_at: Date,
    updated_at: Date
});

// 在Schema里添加自定义方法
userSchema.methods.capitalizeName = function () {
    this.name = this.name.toUpperCase();
    return this.name;
};

var User = mongoose.model('User', userSchema);

module.exports = User;

使用举例

下面就看看咱们自定义的model和方法如何使用：

app.post('/new', function (req, res) {
    var newGuy = new User({
        name: req.body.name,
        username: req.body.username,
        password: req.body.password // 千万别用这种密码
    });

    newGuy.capitalizeName(function (err, name) {
        if (err) {
            res.send({error: err});
            return;
        }

        console.log(`name is ${name}`);
    });

    newGuy.save(function (err) {
        if (err) {
            res.send({error: err});
        } else {
            res.send({message: 'done', user: newGuy});
        }

这是在一个Http POST请求里获取用户的name, username, password三个值。以后使用User来建立一个新的用户newGuy，调用方法newGuy.capitalizeName，注意这个犯法里有回调。最后使用save方法保存用户数据。因为在定义User这个model的时候指定username是惟一的，因此屡次插入操做只会保存一条数据用户名相同的数据。

在保存之前调用的方法

咱们在model里也定义了created_at等关于时间的属性，这样就知道何时doc被建立。咱们使用Schema的pre方法来保证保存之前能够调用执行一段特定的代码。

// 保存之前执行的代码
userSchema.pre('save', function (next) {
    var currentDate = new Date();
    this.updated_at = currentDate;

    if (!this.created_at) {
        this.created_at = currentDate;
    }

    next();
});

如今每次save都会执行这段代码，给model的created_at和updated_at设定时间。这也是一个hash密码的地方。毕竟直接保存明文密码太不该该了。

Create

用前面定义好的model：User而后new一个新的变量。调用内置的save方法就会建立一个新的user。

// create a new user
var newUser = User({
  name: 'Peter Quill',
  username: 'starlord55',
  password: 'password',
  admin: true
});

// save the user
newUser.save(function(err) {
  if (err) throw err;

  console.log('User created!');
});

读取

读取就是根据必定的条件把数据库里的user读出来。由这个条件能够决定咱们是读一个，几个仍是所有user。

读取所有

app.get('/all', function (req, res) {
    User.find({}, function (err, users) {
        if (err) {
            res.send({message: 'error'});
            return;
        }

        res.send({message: 'done', data: users});
    });
});

请求结果：

{
    "message": "done",
    "data": [
        {
            "_id": "576bfe34137a575cf8c854cc",
            "name": "sue",
            "age": 26,
            "status": "A"
        },
        {
            "_id": "576df2960f0a5baabce7bc16",
            "name": "JACK",
            "username": "uncle_charlie",
            "password": "123456",
            "__v": 0
        }
    ]
}

查找一个

app.get('/some/:name', function (req, res) {
    var name = req.params.name;
    User.find({name: name.toUpperCase()}, function (err, user) {
        if (err) {
            res.send({message: 'error'});
            return;
        }

        res.send({message: 'done', data: user});
    });
});

使用User的name属性的惟一约束查找一个user。由于用户的name在数据库中是大写的，要匹配到用户须要把传过来的参数所有大写以后使用。

用ID查找

app.get('/some/:name/:id', function (req, res) {
    var name = req.params.name;
    var userId = req.params.id;

    if (name === 'none') {
        User.findById(userId, function (err, user) {
            if (err) {
                res.send({message: 'error'});
                return;
            }

            res.send({message: 'done', data: user});
        });
    } else {
        // 略
    } 
});

查询特定user

除了下面给出的方法之外，你能够可使用MongoDB自己的查询方法。

app.get('/find', function (req, res) {
    var lastDay = new Date();
    lastDay.setDate(lastDay.getDate() - 1);

    User.find({admin: false}).where('created_at').gt(lastDay).exec(function (err, users) {
        if (err) {
            res.send({message: 'error'});
            return;
        }

        res.send({message: 'done', data: users});
    });
});

找到昨天添加的非admin用户。

更新

咱们接下来找几个用户出来，修改他们的某些属性并再次存入数据库。

app.post('/update/:name', function (req, res) {
    var name = req.params.name.toUpperCase();
    User.find({ name: name.toUpperCase() }, function (err, user) {
        if (err) {
            res.send({ message: 'error' });
            return;
        }

        var aUser = user[0];
        // 更改属性
        // 若是是admin的所有撤销，不是admin则指定为admin
        aUser.admin = req.body.admin;

        // 定位为Beijing
        aUser.location = req.body.location;

        // save
        aUser.save(function (err, data) {
            if (err) {
                res.send({ message: 'error' });
                return;
            }

            console.log(`done ${data}`);
            res.send({message: 'done', data: aUser});
        });
    });
});

查找并更新

User.findOneAndUpdate({name: name}, {username: 'mr_charlie'}, function (err, user) {
    if (err) {
        res.send({ message: 'error' });
        return;
    }

    res.send({message: 'done', data: user});
});

还可使用一个相似的方法findByIdAndUpdate，各位能够在这里查看详细的介绍。

删除

获取一个用户，而后删除。

app.get('/delete/:name', function (req, res) {
    var un = req.params.name.toUpperCase();
    User.find({name: un}, function (err, user) {
        if (err) {
            res.send({ message: 'error'});
            return;
        }

        if (user.length <= 0) {
            res.send({ message: 'error', 'data': 'no such user'});
            return;
        }

        user[0].remove(function(err, data) {
            if (err) {
                res.send({ message: 'error' });
                return;
            }

            console.log(`data to remove ${data}`);
            res.send({messge: 'done', data: data});
        });
    });
});

用户名会在get的路径中传入：http://localhost:4100/delete/sue。以后使用这个用户名找到用户名称为SUE的所有用户（这时是个数组），若是这个用户数组大于0，则删除数组中的第一个model。最后，把删除的用户数据经过RESTful API发送出去。

相似的方法还有：findOneAndRemove、findByIdAndRemove。

// find the user with id 4
User.findOneAndRemove({ username: 'starlord55' }, function(err) {
  if (err) throw err;

  // we have deleted the user
  console.log('User deleted!');
});

// find the user with id 4
User.findByIdAndRemove(4, function(err) {
  if (err) throw err;

  // we have deleted the user
  console.log('User deleted!');
});

处理回调

前部分的内容都是关于如何使用mongoose处理数据的经常使用的增删改查的方法。在其中涉及到了不少的回调。好比查找以后更新这一部分，首先要查找，在回调中得知成功以后调用更新，更新回调显示成功以后把数据发回客户端。在以上步骤中任意一步出错则发送错误数据。

User.find({ name: name.toUpperCase() }, function (err, user) {
    // 1. 查找之后的回调
    if (err) {
        res.send({ message: 'error' });
        return;
    }
    
    // 修改数据

    // save
    aUser.save(function (err, data) {
        // 更新的回调
        if (err) {
            res.send({ message: 'error' });
            return;
        }
        // 更新成功
        console.log(`done ${data}`);
        res.send({ message: 'done', data: aUser });
    });
});

查找并更新的两个回调。

下面就来说解如何消除回调。这样的神器叫作bluebird。bluebird使用了一种叫作Promise的工具，能够经过then方法依次的分解回调的代码。

安装bluebird。

npm install bluebird

在引入的mongoose里设置这个bluebird。

app.post('/asyncupdate/:name', function (req, res) {
    var name = req.params.name.toUpperCase();
    User.find({ name: name.toUpperCase() }).exec().then(function (users) {
        if (users.length <= 0) {
            throw new Error('no such user');
        }

        var aUser = users[0];
        // 更改属性
        // 若是是admin的所有撤销，不是admin则指定为admin
        aUser.admin = req.body.admin;

        // 定位为Beijing
        aUser.location = req.body.location;

        return aUser.save();
    }).then(function (user) {
        console.log('updated user: ' + user.name);
        res.send({message: 'done', data: user});
    }).catch(function (err) {
        console.log('err ' + err);
        res.send({ message: 'error' });
    });
});

和上面的使用回调的查找-更新比较一下，使用Promise之后代码不只容易读，并且之后也会更加容易维护。固然，Promise能作的绝对不只是这样写。有兴趣的同窗能够到bluebird官网查看他们的文档。

最后

Mongoose是一个MongoDB下很是好用的ORM库，并且简单易学。是开发的好帮手。另外还有bluebird加成。处理mongodb的时候就更加的驾轻就熟了。