#yyds干货盘点#MongoDB 封装 CRUD 方法

CRUD是指创建(Create)、读取(Read)、更新(Update)和删除(Delete)四种基本的数据处理操作。

在软件开发中，CRUD方法通常用于对数据库或其他存储系统中的数据进行操作。

具体来说，CRUD方法包括以下四种操作：

• 创建(Create) ：向数据库或其他存储系统中插入新数据。
• 读取(Read) ：从数据库或其他存储系统中获取数据。
• 更新(Update) ：更新数据库或其他存储系统中已有的数据。
• 删除(Delete) ：从数据库或其他存储系统中删除数据。

这些操作可以通过编写相应的程序实现，以便在应用程序中对数据进行处理和管理。

例如，在一个商店的库存管理系统中：

• 使用CRUD方法可以新增商品(Create)、
• 查询某个商品的库存数量(Read)、
• 修改商品的价格和库存数量(Update)
• 从库存中删除商品(Delete)。

实现步骤

首先，需要安装相应的依赖项，包括 koa，koa-router，koa-bodyparser 和 mongoose。

可以通过在终端中运行以下命令进行安装：

npm install koa koa-router koa-bodyparser mongoose

然后，在项目中创建一个 db.js 文件，封装 MongoDB 的连接和操作方法：

const mongoose = require('mongoose');

// 连接数据库
mongoose.connect('mongodb://localhost/mydb', { useNewUrlParser:true })
  .then(() => console.log('MongoDB connected'))
  .catch(err => console.error(err));

// 定义数据模型
const userSchema = new mongoose.Schema({
  name: String,
  age: Number,
  email: String
});
const User = mongoose.model('User', userSchema);
 
// 封装 CRUD 操作 
module.exports = {
  // 获取所有用户数据
  async getUsers() {
    return await User.find();
  },
  // 新增用户数据
  async addUser(data) {
    const user = new User(data);
    return await user.save();
  },
  // 根据 ID 获取用户数据
  async getUserById(id) {
    return await User.findById(id);
  },
  // 根据 ID 更新用户数据
  async updateUserById(id, data) {
    return await User.findByIdAndUpdate(id, data);
  },
  // 根据 ID 删除用户数据
  async deleteUserById(id) {
    return await User.findByIdAndDelete(id);
  }
};

在上面的代码中，我们定义了 User 数据模型，并在 getUsers()、addUser()、getUserById()、updateUserById() 和 deleteUserById() 方法中封装了 MongoDB 的 CRUD 操作。

接下来，需要在项目的入口文件中创建一个 Koa 应用，并在路由中使用上述封装的方法：

const Koa = require('koa');
const Router = require('koa-router');
const bodyParser = require('koa-bodyparser');
const db = require('./db');

const app = new Koa();
const router = new Router();

// 解析请求体
app.use(bodyParser());

// 获取所有用户数据
router.get('/users', async (ctx) => {
  const users = await db.getUsers();
  ctx.body = users;
});

// 新增用户数据
router.post('/users', async (ctx) => {
  const { name, age, email } = ctx.request.body;
  const user = await db.addUser({ name, age, email });
  ctx.body = user;
});

// 根据 ID 获取用户数据
router.get('/users/:id', async (ctx) => {
  const { id } = ctx.params;
  const user = await db.getUserById(id);
  ctx.body = user;
});

// 根据 ID 更新用户数据
router.put('/users/:id', async (ctx) => {
  const { id } = ctx.params;
  const { name, age, email } = ctx.request.body;
  const user = await db.updateUserById(id, { name, age, email });
  ctx.body = user;
});

// 根据 ID 删除用户数据
router.delete('/users/:id', async (ctx) => {
  const { id } = ctx.params;
  await db.deleteUserById(id);
  ctx.status = 204;
});

app.use(router.routes());

app.listen(3000);

在上面的代码中，我们创建了一个 Koa 应用，并在路由中使用封装的 CRUD 方法处理对应的 HTTP 请求。其中，通过 koa-bodyparser 中间件解析请求体，使用 :id 对 ID 进行占位符处理。

最后，通过在终端中运行以下命令启动应用：

node app.js

即可通过访问 http://localhost:3000/users 等 API 进行 MongoDB 的 CRUD 操作。

案例：用户模块 CRUD 封装 改造

在controller文件夹下，新建utils文件夹，并且新建index.js文件

// controller/utils/index.js
/**
 * 用于添加数据的公共方法
 * @param {*} model 
 * @param {*} params 
 * @param {*} ctx 
 * @returns 
 */
const add = (model, params, ctx) => (
    model.create(params).then(rel => {
        if (rel) {
            ctx.body = {
                code: 200,
                msg: '添加成功',
                data: rel
            }
        } else {
            ctx.body = {
                code: 300,
                msg: '添加失败'
            }
        }

    }).catch(err => {
        ctx.body = {
            code: 400,
            msg: '添加时出现异常'
        }
        console.error(err)
    })
)

/**
 * 用于修改数据的公共方法
 * @param {*} model 
 * @param {*} where 
 * @param {*} params 
 * @param {*} ctx 
 * @returns 
 */
const update = (model, where, params, ctx) => (
    model.updateOne(where, params).then(rel => {
        ctx.body = {
            reslut: rel
        }
    }).catch(err => {
        ctx.body = {
            code: 400,
            msg: '修改时出现异常'
        }
        console.error(err)
    })
)

/**
 * 用于删除的公共方法
 * @param {*} model 
 * @param {*} where 
 * @param {*} ctx 
 * @returns 
 */
const del = (model, where, ctx) => (
    model.findOneAndDelete(where).then(rel => {
        ctx.body = {
            reslut: rel
        }
    }).catch(err => {
        ctx.body = {
            code: 400,
            msg: '删除时出现异常'
        }
        console.error(err)
    })
)

/**
 * 用于查询所有数据的公共方法
 * @param {*} model 
 * @param {*} where 
 * @param {*} ctx 
 * @returns 
 */
const find = (model, where, ctx) => (
    model.find(where).then(rel => {
        ctx.body = {
            result: rel
        }
    }).catch(err => {
        ctx.body = {
            code: 400,
            msg: '查询时出现异常'
        }
        console.error(err)
    })
)

/**
 * 查询单条数据的公共方法
 * @param {*} model 
 * @param {*} where 
 * @param {*} ctx 
 * @returns 
 */
const findOne = (model, where, ctx) => (
    model.findOne(where).then(rel => {
        ctx.body = {
            result: rel
        }
    }).catch(err => {
        ctx.body = {
            code: 400,
            msg: '查询时出现异常'
        }
        console.error(err)
    })
)

module.exports = {
    find,
    findOne,
    add,
    update,
    del
}

在controller文件夹下，修改user文件夹

// controller/user.js
const {User} = require('../models')
const crud = require('./crudUtil')

//添加系统用户
const userAdd = async (ctx) => {
  let {username = '',pwd = ''} = ctx.request.body
  await crud.add(User,{username,pwd},ctx)
}

//修改用户
const userUpdate = async (ctx) => {
    let params = ctx.request.body
    await crud.update(
            User,
            {_id:params._id},
            {username:params.username,pwd:params.pwd},
            ctx
        )
}

//删除用户
const userDel = async (ctx) => {
    let {_id} = ctx.request.body
    await crud.del(User,{_id},ctx)
}

//查询所有用户
const userFind = async (ctx) => {
    await crud.find(User,null,ctx)
}

//查询单个用户
const userFindOne = async (ctx) => {
    await crud.findOne(User,{_id:ctx.params.id},ctx)
}

module.exports = {
    userAdd,
    userUpdate,
    userDel,
    userFind,
    userFindOne
}