【封装】nodejs操作mongo数据库

最新推荐文章于 2022-11-07 20:31:43 发布
最新推荐文章于 2022-11-07 20:31:43 发布
阅读量168 收藏 1
点赞数
分类专栏： node.js 文章标签： mongodb node.js nodejs 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caiweichao123/article/details/104953838
版权

【封装】nodejs操作mongo数据库

本文将涉及以下知识点：

  1. nodejs操作数据库的基本代码
  2. 封装数据库链接操作
  3. 封装 增删改查 数据库的操作
  4. 封装根据商品id动态查询商品详情的操作
  5. 用Promise避免回调地狱

nodejs操作数据库的基本代码

安装+引入mongodb模块

npm i mongodb
const mongodb=require("mongodb")

实例化并连接数据库

let mongoCt = mongodb.MongoClient; //实例化
mongoCt.connect(
  "mongodb://127.0.0.1:27017",	//数据库协议+地址+端口
  { useUnifiedTopology: true }, //加上这个参数就不会警告了
  (err, client) => {}					 //err连接失败 client连接后的客户端
);

链接库和集合

let db = client.db("数据库名");
let clt = db.collection("集合名");

集合操作

增
clt.insertOne({要插入的数据},(err,res)=>{})	//err 插入失败 res 插入成功返回的对象
clt.insertMany(arr数据,(err,res)=>{})				//插入多条数据

res ：res.result , n 结果 ok 状态,
ops: [ { name: ‘gg’, price: 23, _id: 5e6fa2f59dead35908f070eb } ], 内容，数组
insertedCount: 1, 插入的行数
insertedId: 5e6fa2f59dead35908f070eb 插入后生成的id

删
 clt.deleteOne({条件},(err,result)=>{})		
 clt.deleteMany({条件},(err,result)=>{})
改
 clt.updateOne({ 条件 }, { $set: { 修改后对象} }, (err, res) => {});
 clt.updateMany({ 条件 }, { $set: { 修改后对象 } }, (err, res) => {});
查
//写法一
clt.find({条件},{skip:1,limit:1,projection:{key:1},(err,res)=>{
  res.toArray((err,data)=>{})
})	//res为返回的数据对象,data为该对象转换后的数据数组
//写法二
clt.find({}).toArray((err, data) => {});	//效果同上

关闭数据库

client.close()

链接数据库封装

由于链接数据库时常用的操作，我们可以将其封装

为了避免回调地狱，我打算采用Promise

常规操作，将需要的模块下载好引入

const mongodb = require("mongodb");
let mongoCt = mongodb.MongoClient; //实例化

封装为open方法

let open = ({
  dbName = "shop", //数据库名字
  collectionName, //集合名字
  url = "mongodb://127.0.0.1:27017" //连接数据库地址
}) => {
  return new Promise((resolve, reject) => {
    mongodCt.connect(url, { useUnifiedTopology: true }, (err, client) => {
      if (err) {
        reject(err); //连接数据库失败执行该函数，携带错误为参数
      } else {
        let db = client.db(dbName);
        let collection = db.collection(collectionName);
        resolve({ collection, client }); //成功则执行，携带集合 后续可操作，携带客户端最后可以关闭
      }
    });
  });
};

查询数据

let findList = ({
  dbName = "shop",
  collectionName, //操作的集合名
  _page, //第几页
  _limit, //跳过第几个
  _sort, //按照哪个区域排序
  _sortRule = "asc", //按照什么规则排序
  q, //搜索的需要的关键字
  field = "name" //查询哪个区域的关键字
}) => {
  //生成检索条件,模糊查询
  //  let rule = q ? { [field]: new RegExp(q, "g") } : {};         //方法一
  let rule = q ? { [field]: eval(`/.*?${q}.*/`) } : {}; //方法二，推荐
  if (_sortRule == "asc") {
    _sortRule = 1;
  } else if (_sortRule == "des") {
    _sortRule = -1;
  }
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        collection
          .find(rule, {
            skip: _page * _limit, //跳过多少数据
            limit: _limit, //每一页显示的数量
            sort: { [_sort]: _sortRule } //排序字段,当一个变量作为key使用的时候，需要采用[]的语法
          })
          .toArray((err, result) => {
            if (!err && result.length > 0) {
              //有数据则返回
              resolve({ err: 0, data: result });
            } else {
              reject({ err: 1, msg: "没有查到数据！" });
            }
            client.close(); //关闭链接
          });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

根据id查询 数据详情

由于mongodb的id默认是一个对象，所以我们需要导入一个模块，来将字符串转换为对象，用于查询

let objectId = mongodb.ObjectId;//把字符串转成ObjectId的对象类型

封装

let findDetail = ({ dbName = "shop", collectionName, _id = null }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        if (_id.length === 24) {    //判断id是否符合标准
          collection.find({ _id: objectId(_id) }).toArray((err, data) => {
            if (!err && data.length > 0) {  //判断是否找到对应数据
              resolve({ err: 0, data: data[0] });
            } else {
              resolve({ err: 0, msg: "查询不到该数据" });
            }
            client.close(); //完成查询后记得关闭数据链接
          });
        } else {
          reject({ err: 1, msg: "id长度有误！" });
        }
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

插入数据

let insert = ({ data, collectionName, dbName = "shop" }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        collection.insert(data, (err, res) => {
          if (err) {
            reject({ err: 1, msg: "插入数据失败！" });
          } else {
            resolve({ err: 0, msg: "插入数据成功", res });
          }
          client.close();
        });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

删除数据

let del = ({ data, collectionName, dbName = "shop" }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        if (data._id) {
          data._id = objectId(data._id); //将字符串转成objectid对象
        }
        collection.deleteMany(data, (err, res) => {
          if (err) {
            reject({ err: 1, msg: "删除数据失败" });
          } else {
            resolve({ err: 0, msg: "删除数据成功", res });
          }
          client.close();
        });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

修改数据

let update = ({ data, updateData, collectionName, dbName = "shop" }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        if (data._id) {
          data._id = objectId(data._id); //将字符串转成objectid对象
        }
        collection.updateMany(data, { $set: updateData }, (err, res) => {
          if (err) {
            reject({ err: 1, msg: "修改数据失败" });
          } else {
            resolve({ err: 0, msg: "修改数据成功", res });
          }
          client.close();
        });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

导出以上模块

module.exports.open = open;
module.exports.findDetail = findDetail;
module.exports.findList = findList;
module.exports.insert = insert;
module.exports.del = del;
module.exports.update = update;

以上就是基本操作数据库的封装了，都是本人的学习记录，如有不对，欢迎指出~

全部代码如下

index.js

const mongodb = require("./mongo");
const express = require("express");
// const multer = require("multer");
const bodyParser = require("body-parser");

let app = express();
app.listen(3000, () => {
  console.log("监听3000端口成功");
});

//查询数据列表接口
app.get("/api/goods", async (req, res) => {
  if (req.query._id) {
    res.redirect(`/api/goods/${req.query._id}`);
    return;
  }
  let { _page, _limit, _sort, q, field, _sortRule } = req.query;
  _page = _page - 1;
  _limit = _limit - 0;
  _sort = _sort || "name";

  try {
    let result = await mongodb.findList({
      collectionName: "goods",
      _page,
      _limit,
      _sort,
      _sortRule,
      q,
      field
    });
    res.send(result); //返回异步函数执行成功的值
  } catch (err) {
    res.send(err); //捕获执行出错并返回
  }

  //   mongodb
  //     .findList({ collectionName: "goods", _page, _limit, _sort, q })
  //     .then(result => {
  //       res.send(result);
  //     })
  //     .catch(err => {
  //       res.send(err);
  //     });
});

//查询数据详情接口
app.get("/api/goods/:_id", (req, res) => {
  let { _id } = req.params;
  mongodb
    .findDetail({ _id, collectionName: "goods" })
    .then(result => {
      res.send(result);
    })
    .catch(err => {
      res.send(err);
    });
});
app.use(bodyParser());
//插入数据接口
app.post("/api/goods/insert", (req, res) => {
  let data = req.body;
  console.log(data);
  if (JSON.stringify(data) !== "{}") {
    mongodb
      .insert({ data, collectionName: "goods" })
      .then(result => {
        res.send(result);
      })
      .catch(err => {
        res.send(err);
      });
  } else {
    res.send({ err: 1, msg: "请填写要插入的数据内容！" });
  }
});

//删除数据
app.post("/api/goods/del", (req, res) => {
  let data = req.body;
  if (JSON.stringify(data) !== "{}") {
    mongodb
      .del({ data, collectionName: "goods" })
      .then(result => {
        res.send(result);
      })
      .catch(err => {
        res.send(err);
      });
  } else {
    res.send({ err: 1, msg: "请填写要删除的数据内容！" });
  }
});

//修改数据接口
app.post("/api/goods/update", (req, res) => {
  let { data, updateData } = req.body;
  console.log(req.body);
  //   data = JSON.parse(data);  //将获取的字符串转换为对象作为参数传过去
  //   updateData = JSON.parse(updateData);
  if (JSON.stringify(data) !== "{}" && JSON.stringify(updateData) !== "{}") {
    mongodb
      .update({ data, updateData, collectionName: "goods" })
      .then(result => {
        res.send(result);
      })
      .catch(err => {
        res.send(err);
      });
  } else {
    res.send({ err: 1, msg: "请填写要修改的数据内容 或 修改后的数据内容" });
  }
});

mongo.js

const mongodb = require("mongodb");
let mongoCt = mongodb.MongoClient; //实例化
let objectId = mongodb.ObjectId; //把字符串转成ObjectId的对象类型

let open = ({
  dbName = "shop", //数据库名字
  collectionName, //集合名字
  url = "mongodb://127.0.0.1:27017" //连接数据库地址
}) => {
  return new Promise((resolve, reject) => {
    mongoCt.connect(url, { useUnifiedTopology: true }, (err, client) => {
      if (err) {
        reject(err); //连接数据库失败执行该函数，携带错误为参数
      } else {
        let db = client.db(dbName);
        let collection = db.collection(collectionName);
        resolve({ collection, client }); //成功则执行，携带集合 后续可操作，携带客户端最后可以关闭
      }
    });
  });
};

//查询
let findList = ({
  dbName = "shop",
  collectionName, //操作的集合名
  _page, //第几页
  _limit, //跳过第几个
  _sort, //按照哪个区域排序
  _sortRule = "asc", //按照什么规则排序
  q, //搜索的需要的关键字
  field = "name" //查询哪个区域的关键字
}) => {
  //生成检索条件,模糊查询
  //   let rule = q ? { [field]: new RegExp(q, "g") } : {};         //方法一
  let rule = q ? { [field]: eval(`/.*?${q}.*/`) } : {}; //方法二，推荐
  if (_sortRule == "asc") {
    _sortRule = 1;
  } else if (_sortRule == "des") {
    _sortRule = -1;
  }
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        collection
          .find(rule, {
            skip: _page * _limit, //跳过多少数据
            limit: _limit, //每一页显示的数量
            sort: { [_sort]: _sortRule } //排序字段,当一个变量作为key使用的时候，需要采用[]的语法
          })
          .toArray((err, result) => {
            if (!err && result.length > 0) {
              //有数据则返回
              resolve({ err: 0, data: result });
            } else {
              reject({ err: 1, msg: "没有查到数据！" });
            }
            client.close(); //关闭链接
          });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

//根据动态获取id数据的详情数据
let findDetail = ({ dbName = "shop", collectionName, _id = null }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        if (_id.length === 24) {
          //判断id是否符合标准
          collection.find({ _id: objectId(_id) }).toArray((err, data) => {
            if (!err && data.length > 0) {
              //判断是否找到对应数据
              resolve({ err: 0, data: data[0] });
            } else {
              resolve({ err: 0, msg: "查询不到该数据" });
            }
            client.close(); //完成查询后记得关闭数据链接
          });
        } else {
          reject({ err: 1, msg: "id长度有误！" });
        }
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

//增
let insert = ({ data, collectionName, dbName = "shop" }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        collection.insert(data, (err, res) => {
          if (err) {
            reject({ err: 1, msg: "插入数据失败！" });
          } else {
            resolve({ err: 0, msg: "插入数据成功", res });
          }
          client.close();
        });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

//删
let del = ({ data, collectionName, dbName = "shop" }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        if (data._id) {
          data._id = objectId(data._id); //将字符串转成objectid对象
        }
        collection.deleteMany(data, (err, res) => {
          if (err) {
            reject({ err: 1, msg: "删除数据失败" });
          } else {
            resolve({ err: 0, msg: "删除数据成功", res });
          }
          client.close();
        });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};

//改
let update = ({ data, updateData, collectionName, dbName = "shop" }) => {
  return new Promise((resolve, reject) => {
    open({ dbName, collectionName })
      .then(({ collection, client }) => {
        if (data._id) {
          data._id = objectId(data._id); //将字符串转成objectid对象
        }
        console.log(data, updateData);

        collection.updateMany(data, { $set: updateData }, (err, res) => {
          if (err) {
            reject({ err: 1, msg: "修改数据失败" });
          } else {
            resolve({ err: 0, msg: "修改数据成功", res });
          }
          client.close();
        });
      })
      .catch(err => {
        reject({ err: 1, msg: "数据库链接失败！" });
      });
  });
};
module.exports.open = open;
module.exports.findDetail = findDetail;
module.exports.findList = findList;
module.exports.insert = insert;
module.exports.del = del;
module.exports.update = update;
Cc.*
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解nodejs操作mongodb数据库封装DB类
01-20
这个DB类也算是我经历了3个实际项目应用的，现分享出来，有需要的请借鉴批评。 上面的注释都挺详细的，我使用到了nodejs的插件mongoose，用mongoose操作mongodb其实蛮方便的。 关于mongoose的安装就是 npm install -g mongoose 这个DB类的数据库配置是基于auth认证的，如果您的数据库没有账号与密码则留空即可。 /** * mongoose操作类(封装mongodb) */ var fs = require('fs'); var path = require('path'); var mongoose = require('mongoos
nodejs mongodb 数据库封装DB类 -转
04-21 174
使用到了nodejs的插件mongoose，用mongoose操作mongodb其实蛮方便的。 关于mongoose的安装就是 npm install -g mongoose 这个DB类的数据库配置是基于auth认证的，如果您的数据库没有账号与密码则留空即可。 /** * mongoose操作类(封装mongodb) */ var fs = require('...
node.js操作Mongodb数据库
weixin_33691700的博客
10-03 151
一、node.js对于mongodb的基本操作 1、数据库的开机 首先我们要先对数据库进行开机的操作，建立一个文件夹用于存放数据库文档。如D:\mongo，接下去在cmd当中键入命令-> mongod --dbpath D:\mongo来实现数据库的开机。如下图所示： 接下去就保持这个cmd控制面板处于这种状态，以确保数据库处于开...
Nodejs-Mongodb模块常用的操作封装
SolitudeAlma的博客
06-06 340
Nodejs-Mongodb模块常用的操作封装
nodejs查询mongo数据
weixin_44006596的博客
02-17 314
const mongoUrl = ‘mongodb://username:password@IP:27017/mongoDB’; const MongoClient = require(‘mongodb’).MongoClient; MongoClient.connect(mongoUrl, {useNewUrlParser: true, useUnifiedTopology: true}, async function(err, db) { if (err) throw err; console.log(
nodejs 操作mongodb，插查删改
07-10
描述提到的是一个基于Node.js的类文件，可能是封装了这些数据库操作的工具类，但没有经过大规模并发测试，只在本地环境中进行了验证。这意味着这个类文件可能包含了一些基本的数据库操作方法，如插入（insert）、...
EJblog:基于Nodejs + Mongo + jQuery + Bootstrap建立个人博客系统
03-11
电子博客 Nodejs（Express）+ MongoDB + jQuery + Bootstrap个人博客。 顾名思义Express（E）jQuery（J） 这是一个开源的个人博客系统。...---- db.js 封装了对数据库的操作（增删改查） ---- md5.
重新封装了下node-mongo服务.zip
11-05
# mongo.js 封装了一些基本的node对mongo操作 # 使用方法，直接node servicemongo.js 就行，也可以在另一个项目里调用servicemongo的start # 注意 如果node包不能用，看下错误日志，缺什么就直接npm i XXX 装上就好
angular-mongo-node:这是一个通过 AngularJS 与 mongo 数据库连接的应用程序。 后端使用NodeJS
06-27
角mongo节点 这是一个通过 AngularJS 与 mongo 数据库连接的应用程序。 后端使用NodeJS ... route/index.js：这个文件包括一个连接mongo数据库的函数，一个将检索到的数据以JSON格式保存并发送到前
nodejs下mongoDB的使用
weixin_45838680的博客
07-15 285
一、无DAO层，直接操作数据库 /** * Created by Danny on 2015/9/25 9:16. */ var express = require("express"); var app = express(); var MongoClient = require('mongodb').MongoClient; app.get("/",function(req,res){ //url就是数据库的地址。/表示数据库 //假如数据库不存在，没有关系，程序会帮你自动创建一
铱：针对Node.js的高性能MongoDB ORM
02-04
铱 适用于MongoDB的高性能，IDE友好型ODM Iridium旨在为Node.js上的MongoDB提供高性能，易于使用的编辑器ODM。 Iridium尝试采用一种难以置信的轻量级实现，而不是采用Mongoose和其朋友之类的ODM经常喜欢的“重新实现一切”方法，而是要求您学习全新的API并将您锁定为特定的编码样式，当您想做任何更复杂的事情时，它会变得很重要，并让您摆脱困境。 这也意味着，如果您熟悉MongoDB CLI，您应该会发现使用Iridium非常自然，所有数据库方法均会返回其结果的承诺和合理的承诺，如果希望使用它们，请输入带注释的结果。 安装 Iridium利用了最新的@t
mongoose - 让node.js高效操作mongodb
baoaoba9317的博客
05-09 408
Mongoose库简而言之就是在node环境中操作MongoDB数据库的一种便捷的封装，一种对象模型工具，类似ORM，Mongoose将数据库中的数据转换为JavaScript对象以供你在应用中使用。 当然要使用的话，必须要先安装好环境Node.js与MongoDB =》 MongoDB安装 MongoDB是目前最流行的noSQL数据库之一，它是专为node.js而开发的，理解下与我...
nodejs-第四天-使用MongoDB、shell增删改查操作、聚集集合操作
m0_37068028的博客
05-19 1524
nodejs-第四天-使用MongoDB、shell增删改查操作、聚集集合操作
从零开始node.js入门项目（四）数据对象（mongodb）
复杂思考，简单编码
01-07 1697
初识mogodb 全新开始，mogodb也是第一次用，这里记录一些认为比较重要的知识点。 1、mongodb 是用面对“文档”的数据库。 2、"文档"相当于关系数据库的行，由键和值组成，如用javascript语言表示一个"文档" {'user_name':'byts','user_psw':'123456'} 3、"集合"等于关系数据库中的表，虽然"集合"是无模式的（一个集合中可以放任
mongoose-面向对象操作mongodb的Nodejs框架
imherer的博客
07-30 236
介绍 无论是mysql还是mongodb，传统的与数据库交互的方式都是按照他们提供的API来写代码。它们提供的API往往不是很容易理解，而且难以记忆，如果传错了参数，写错一个符号都要查文档。 ORM（对象关系映射，Object Relational Mapping）框架，允许我们面向对象操作，不需要记忆任何的数据库API，只需要操作对象即可，由框架底层去调用数据库API，这样就大大提高了程序员的开发效率。 不过既然多了一层封装，肯定要损失一点点的性能，可以忽略不计。 在NodeJS中，操作mong...
Nodejs 操作 MongoDb 数据库
weixin_44714325的博客
02-22 161
一、在 Nodejs 中使用 Mongodb Nodejs 操作 mongodb 数据库官方文档： http://mongodb.github.io/node-mongodb-native/ npm install mongodb --save 或者 cnpm install mongodb --save 或者 yarn add mongodb 二、Nodejs 连接 MongoDb 数据库 const MongoClient = require('mongodb').MongoClient; cons
node.js操作MySQL数据库批量插入删除数据
weixin_62603074的博客
11-07 2154
如何实现数据库多条数据的删除和插入
mongodb里面 find方法
热门推荐
ppwwp的专栏
04-23 1万+
MongoDB常用操作 一、查询 find方法 db.collection_name.find(); 查询所有的结果： select * from users; db.users.find(); 指定返回那些列（键）： select name, skills from users; db.users.find({}, {‘name’ : 1, ‘skills’ : 1}); 补...
nodejs 与 mongodb关于浮点型的坑
wushichao0325的博客
08-18 1049
nodejs 与 mongodb关于浮点型的坑背景解决步骤第一步第二步 背景 在一次使用中，出现存入数据库的数字比如2.15，但是通过代码读出来后为2.1500000000001的情况。 解决步骤 第一步 nodejs在使用mongoose作为模型映射时，建议浮点类型的字段定义为mongoose.Schema.Types.Decimal128 第二步 检查nodejs中数据转换时是否使用过类似parseFloat函数，因为这个方法是将字符串数字转化为float的数值类型，但是mongodb数据库的数据类型浮
nodejs操作mysql数据库
最新发布
07-28
在Node.js中操作MySQL数据库，你需要引入对应的数据库操作模块，并进行必要的配置。以下是一个示例代码： ```javascript const mysql = require('mysql'); const connection = mysql.createConnection({ host: '...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值