mongoose 使用记录

文档地址：www.npmjs.com/package/mon…

初始化

安装

npm install mongoose

引入

const mongoose = require('mongoose');

连接数据库

const mongoose = require('mongoose');
const config = require('./index');  

mongoose.connect(
    config.URL,  // 数据库地址
);

成功提示和失败警告

connect() 返回一个状态待定（pending）的连接， 接着我们加上成功提醒和失败警告。

const db = mongoose.connection;

db.on('error', ()=>{
    log4js.error('*** 数据库连接失败 ***')
});

db.on('open', ()=>{
    log4js.info('*** 数据库连接成功 ***')
})

Schema

定义一个 Schema

Mongoose 的一切始于 Schema。每个 schema 都会映射到一个 MongoDB collection (数据库表)，并定义这个collection里的文档的构成。

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

let blogSchema = new Schema({
    title:  String,
    author: String,
    body:   String,
    date: { type: Date, default: Date.now },
});

创建一个 Model

我们要把 schema 转换为一个 Model， 使用 mongoose.model(modelName, schema) 函数：

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

- 参数1： 是collection的单数名称，
  也就是说，当你的数据库中没有任何集合的时候，当你使用Mongoose连接到MongoDB，
  并准备插入数据时，Mongoose会自动为你创建一个叫`Blog`的集合。

- 参数2： 调用`new Schema`所创建的`Schema`

实例说明

下面我们使用一个创建用户的例子实际使用一下

数据库已经连接成功，从创建用户 Schema 开始

用户Schema & Model

创建文件 models/userSchema.js

// 引入mongoose
const mongoose = require('mongoose')

// 定义 用户Schema
const userSchema = mongoose.Schema({
    'userId': Number,   // 用户ID
    'userName': String, // 用户名
    'userPassword': String, // 密码
    'userEmail': String,    // 邮箱
    'mobile': String,       // 手机号
    'createTime': { // 创建时间
        type: Date,
        default: Date.now()
    },
    'updateTime': { // 更新时间
        type: Date,
        default: Date.now()
    },
});

// 创建用户 Model 并导出
module.exports = mongoose.model('users', userSchema, "users");

创建用户

1. 首先判断一下必传字段有没有上传

2. 拿唯一性字段去数据库查询，看有重复

let res = await User.findOne({$or: [{userName}, {userEmail}]}, '_id userName userEmail');
if(res) {
    ctx.body = utils.fail(`系统检测到有重复的用户，信息如下：${res.userName}-${res.userEmail}`);
    return;
}

3. 用户的 userId 字段，是自增长的，所以需要引入另一张自增长表，创建的时候+1

1. 创建一个counters表

2. 用户Id自增长的模型

const mongoose = require('mongoose');
const counterSchema = mongoose.Schema({
    _id: String,
    sequence_value: Number
});

module.exports = mongoose.model('counters', counterSchema, 'counters');

3. 通过 $inc: {sequence_value: 1} 实现sequence_value的自增长

const Counter = require('../models/counterSchema');

let doc = await Counter.findOneAndUpdate({_id: 'userId'}, {$inc: {sequence_value: 1}}, {new: true});

4. 创建用户

通过save()方法创建一条记录

const user = new User({
    userId: doc.sequence_value,
    userName,
    userEmail,
    userPassword: md5('123456'),
    mobile
});
user.save();

这里生成默认密码的时候，用到了md5的依赖

md5文档：www.npmjs.com/package/md5

删除用户

拿到待删除用户的userId，是个数组

这里的删除是个软删除，实际上是通过updateMany()方法批量修改了用户的状态

// 待删除的用户数组
let {userIds} = ctx.request.body;

// 软删除 修改用户状态 state: 2
let res = await User.updateMany({userId: {$in: userIds}}, {state: 2});

if (res.modifiedCount) {
    // 删除成功
}

修改用户信息

使用 findOneAndUpdate() 查找并更新用户信息

// 待更新的用户信息
let {
    userId, userName, userEmail, mobile
} = ctx.request.body;

// 查询并更新用户信息
let res = await User.findOneAndUpdate({userId}, {userEmail, mobile });

ctx.body = utils.success(res.userId, '数据更新成功');

查询用户信息

通过find()方法查询用户信息

因为查询用过到了分页，所以我们封装了一个pager()工具函数，来返回查询条数和查询索引skipIndex

function pager({pageNum=1, pageSize=10}) {
    // 如果是字符串的话，转成数字
    pageNum *= 1;
    pageSize *= 1;

    const skipIndex = (pageNum - 1) * pageSize;
    return {
        page: {
            pageNum,
            pageSize
        },
        skipIndex
    }
}

获取查询条件和分页、索引

const {userId, userName, state} = ctx.request.query;
const {page, skipIndex} = utils.pager(ctx.request.query);

整理查询条件

let params = {};
if (userId) params.userId = userId;
if (userName) params.userName = userName;
if (state && state != '0') params.state = state;

查询用户信息

// 根据条件查询所有用户列表
let query = User.find(params, {
    userPassword: 0
});
let list = await query.skip(skipIndex).limit(page.pageSize);
let total = await User.countDocuments(params);

ctx.body = utils.success({
    page: {
        ...page,
        total
    },
    list
});