exports.mongoose = {
 enable: true,
 package: 'egg-mongoose',
};

mongoose: {
 client: {
 url: prod "htmlcode">

'use strict';

/**
 * @description: Mongoose book Schema,
 */

module.exports = app => {
 const mongoose = app.mongoose;
 const Schema = mongoose.Schema;
 const BookSchema = new Schema({
 desc: { type: String }, /* 书籍描述 */
 name: { type: String }, /* 书籍名称 */
 press: { type: String }, /* 出版社 */
 author: { type: String }, /* 作者 */
 image: { type: Array }, /* 书籍图片列表*/
 price: { type: String }, /* 价格 */
 book_type: { /* 书籍分类id */
 type: Schema.Types.ObjectId,
 ref: 'BookClassify',
 },
 user: { /* 书籍发布者id */
 type: Schema.Types.ObjectId,
 ref: 'User',
 },
 create_time: { type: String }, /* 创建时间 */
 status: { type: String }, /* 状态，1：待购买，2：已购买*/
 look: { type: Number } /* 浏览数量 */
 });
 return mongoose.model('Book', BookSchema);
};


可以看到我们可以通过Schema来定义表结构，可以指定字段的类型及关联，设置完字段后就可以生成model了，这里算是非常简单的配置，更多配置方法可参考文档
(2)、使用mongoose方法
配置完数据表结构后，我们就可以再service层中调用mongoose的方法对文档进行增删查改了，已书籍列表的处理逻辑为例子


async findbookList(data) {
 const { type, page, pageSize, desc, status, userId } = data;
 const searchVal = {}
 if (type) {
 searchVal.book_type = mongoose.Types.ObjectId(type)
 }
 if (status) {
 searchVal.status = status
 }
 if (userId) {
 searchVal.user = mongoose.Types.ObjectId(userId)
 }
 const search_term = {
 $or: [
 { desc: { $regex: desc "htmlcode">

this.ctx.model.Book.create(data,callback);


其中data为json数据结构，callback为操作后的回调函数
查询数据
获取所有数据，返回是一个数组


this.ctx.model.Book.find()


获取一个数据，返回是一个对象


this.ctx.model.Book.findOne()


条件查询


this.ctx.model.Article.find(conditions,callback);


其中conditions为查询的条件，callback为回调函数

conditions有一下几种情况：
具体数据：


this.ctx.model.Book.find
(
{_id：5c4a19fb87ba4002a47ac4d, name: "射雕英雄传" 
}
, callback)
;


条件查询：


"$lt" 小于
"$lte" 小于等于
"$gt" 大于
"$gte" 大于等于
"$ne" 不等于
// 查询价格大于100小于200的书籍数组
this.ctx.model.Book.find({ "price": { $get:100 , $lte:200 }); 


或查询 OR


"$in" 一个键对应多个值
"$nin" 同上取反, 一个键不对应指定值
"$or" 多个条件匹配, 可以嵌套 $in 使用
"$not" 同上取反, 查询与特定模式不匹配的文档

this.ctx.model.Book.find({"name":{ $in: ["射雕","倚天"]} );


删除数据


this.ctx.model.Book.remove(conditions,callback);


更新数据


this.ctx.model.Book.update(conditions, update, callback)


conditions为条件，update是更新的值对象
排序


this.ctx.model.Book.sort({ create_time: -1 });


其中-1表示降序返回。 1表示升序返回
限制数量


this.ctx.model.Book.limit(number);


number表示限制的个数
跳过文档返回


this.ctx.model.Book.skip(number);


number表示跳过的个数,skip经常搭配limit实现分页的功能
条件数组and
在find后面可使用and对查询结果进行进一步条件筛选，相当于并且的意思。


const search_term = {
 $or: [
 { desc: { $regex: desc "htmlcode">

// 在model中配置字段时候指定关联的表名，就可以通过populate来进行表的关联查询
user: { /* 书籍发布者id */
 type: Schema.Types.ObjectId,
 ref: 'User',
 },
 
this.ctx.model.Book.find()
 .populate({
 path: 'user',
 select: { name: 1, image: 1 }
 })


聚合管道Aggregate


this.ctx.model.Template.aggregate([
 { $match: { name } },
 { $sort: { create_time: -1 } },
 { $group: { _id: '$name', user_id: { $first: '$modifier' } } },
 ]);


Mongoose聚合管道aggregate常用的操作有$project 、$match 、$group、$sort、$limit、$skip、$lookup 表关联
批量操作bulkWrite


const template_list = await ctx.model.Template.aggregate([
 { $sort: { create_time: -1 } },
 { $group: { _id: '$name', template_id: { $first: '$_id' }, label: { $first: '$label' } } },
 ]);
 const update_value = [];
 template_list.forEach(item => {
 if (!item.label) {
 update_value.push({
 updateOne: {
 filter: { _id: item.template_id },
 update: { label: '' },
 },
 });
 }
 });
 await ctx.model.Template.bulkWrite(update_value);


可以进行一系列批量增加、删除、更新等操作。
mongoose还有非常多的方法可以提供给我的灵活使用，我们在使用的时候可以结合业务逻辑选择合适的方法来提高我们操作数据库的效率。在我们使用它之前可以认真的阅读官方文档
总结

                                
                                

                                    egg中使用Mongoose,egg,Mongoose