nodejs结合mongodb实现增删改查接口

mongoDB

• 概念：这是非关系型数据库，而mysql是关系型数据库！
• 安装：官网 => https://www.mongodb.com/download-center/community
• 注意点：不用勾选那个 Install MongoDB Comass;
• 配置环境变量： => 就是拿到安装路径 C:\Program Files\MongoDB\Server\4.0\bin
  然后到电脑的属性那边配置环境变量
  系统变量下中的PATH 后面添加这路径即可！C:\Program Files\MongoDB\Server\4.0\bin

mongoDB的相关指令

• 1:mongo => 安装mongo好了之后，在cmd之中输入mongo即可 若是得到mongo的版本，那么就是代表安装成功了！

  • mongo => 即使进入mongo 操作状态 也是最开始验证mongo的安装是否成功！

• 2：mongod => 显示数据库信息！

• 3：show dbs => 查找多少数据库

• 4：use XXX => 创建一个数据库或者切换到该数据库！ （switched to db XXX) => 切换到这个这个XXX数据库！

• 5：db => 就是查看当前的数据库为那个？
  注意点：mongo数据库是由 集合+ 数据组成的

  • 集合：collection => 这是类似于mysql中的表（也就是表格）
  • 数据：document => 这就是类似于mysql中的数据（也就是一行数据row)

• 操作集合

  • 1：创建一个集合
    db.createCollction('数据库集合名称')
  • 2: 查询这个集合
    show collections
  • 3：删除一个集合
    db.集合的名称.drop()

• 操作文档，也就是数据 对数据库的增删改查

  • 查
    1：查询所有数据
    db.集合的名称.find()
    2：查询某一条数据 => 查询这一条name为ppp的数据！
    db.集合的名称.find({name:"ppp"})

  • 增

    • 1：插入一条数据
      db.集合的名称.insertOne({name:"名称",age:10}) => 只有是非数字的都需要添加’’
    • 2：插入多条数据 => 数组里面包含对象的形式！
      db.集合的名称.insertMany([{name:"名称",age:11},{name:"www",age:20}])

  • 删

    • 1：删除一条数据 => 删除name为ppp的这一条数据
      db.集合的名称.deleteOne({name:"ppp"})
    • 2：删除多条数据 => 删除name为ppp还有name为111的这两条数据
      db.集合的名称.deleteMany({name:"ppp"})

  • 改

    • 1：修改单条数据 => 把name为ppp 年龄为18的 修改为姓名为嘿嘿，年龄为20
      db.集合的名称.updateOne( {name:"ppp",age:10 } , { $set : { name:"嘿嘿",age:20} } );

更多查询

查询条件

• 比较查询

  • 大于：$gt
  • 小于：$lt
  • 大于等于：$gte
  • 小于等于：$lte
  • 非等于：$ne

• 包含/不包含：$in/$nin
db.goods.find({id:{$in:[10,18,26,13]}})

• 或：$or

    db.user.find({$or:[{name:'laoxie'},{name:'jingjing'}]})
    db.user.find({$or:[{age:{$gt:18}},{description:"成年"}]})

• 匹配所有：$all
• 判断文档属性是否存在：$exists

    db.user.find({password:{$exists:true}})   //查找属性password存在的用户
    db.user.find({password:{$exists:false}})  //查找属性password不存在的数据
    db.user.find({age:{$in:[null],$exists:true}}) //查找age属性存在但值为null的数据

• 正则表达式
  db.user.find({"name":/jack/i});//查找name属性包含jack的数据（不区分大小写）

筛选

• 限制数量：db.表名.find().limit(数量);
• 跳过指定数量：db.表名.find().skip(数量)
• 排序：sort({key:1})
  • 1 : 升序
  • -1 : 降序

三个放在一起使用的时候，执行的顺序是先 sort(), 然后是 skip()，最后是 limit()

// 把类型为字String的价格按数字排序
    db.goods.find().collation({numericOrdering:true}).sort({price:1})

    // 根据某个值修改文档中的另一个值（把price的值改成sale_price的8折）
    db.goods.find({price:0}).forEach(item=>{                
        db.goods.updateOne({_id:item._id},{$set:{price: item.sale_price*0.8}})
    })

Roto 3T 软件的使用

• mongodb数据库地址
  const url = 'mongodb://localhost:27017'
• 对于需要手动插入数据的时候，记得每一条数据是一个对象 并且对象之间不能使用 ,还有注释等个东西，否则会报错！

使用mongoDB操作数据封装接口

• 官网：https://www.npmjs.com/package/mongodb
• 安装：npm i mongodb

根据官网的教程使用 => 简单的使用

前提是开启了一个服务器哦！ express框架简单的搭建框架！

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'userlist';

// 使用connect方法连接到服务器 操作数据库！
MongoClient.connect(url, function (err, client) { //err错误 client 客户端

  console.log("Connected successfully to server");
  const db = client.db(dbName); //1：匹配数据库
  //2：操作数据库 
  // 操作数据库的前提是：引入数据库，还有连接网址，连接数据库名称，数据库的链接（里面有着：匹配数据库 匹配集合，最后根据所选的集合 操作数据库） 最后关闭数据库！

  client.close(); // 关闭数据库，释放资源
});

封装链接数据库 连接函数！

• 在增删改查调用这个链接数据库方法 connect() => 返回的是一个promise对象成功的结果 因此需要使用await去承接！
• 返回值：一个promise对象，里面有着成功的结果，还有 db(数据库) client(客户端) 需要对象解构的方式去解构！

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'userlist';

async function connect() {
  // 注意点：由于 MongoClient.connect() 返回的是一个promise对象 因此可以使用async 和 await
  // console.log(MongoClient.connect(url)); //（MongoClient.connect(url) 返回一个Promise对象）
  const client = await MongoClient.connect(url); //链接数据库

  const db = client.db(dbName); //匹配数据库
  return {
    client,
    db
  }
}

在增删改查之中调用这个 连接函数

• 操作数据库的前提：
  1：连接数据库 => 也就是连接函数 并且导出db(数据库 用于操作数据库) client(客户端，用于关闭数据库！)
  2：增删改查方法内： 链接数据库 匹配数据库集合，最后根据所选的集合 操作数据库） 最后关闭数据库！

查系列

一个简单的查询所有数据库操作 mongo.js文件

// //查 函数
// 操作数据库的前提是：引入数据库，还有连接网址，连接数据库名称，数据库的链接
// 方法里面：数据库的链接（里面有着：链接数据库 匹配数据库集合，最后根据所选的集合 操作数据库） 最后关闭数据库！
async function find(cloName, query = {}, options = {}) { //参数1：数据库中的集合（表） 参数2：操作的数据库语句 参数3：配置参数 
  //1:链接数据库
  let {
    db,
    client
  } = await connect();
  //2:匹配数据库集合 
  let collection = db.collection(cloName);
  //3：最后根据所选的集合 操作数据库 查询操作
  let result = collection.find(query);

  result = result.toArray(); //返回的是一个数组的形式！给与前端！
  //最后 客户端关闭数据库
  client.close();
  return result; //返回查询结果
}

查询所有商品 goods.js文件

const express = require("express");
const router = express.Router();

const mongo = require("../utils/mongo")

//get 方式查询所有数据 /api/goods 
router.get("/", async (req, res) => {
  //find()参数：参数1：数据库中的集合（表） 参数2：操作的数据库语句 参数3：配置参数 
  let result = await mongo.find("goods", {}, {});
  res.send(result);
})

module.exports = router;

一个带有分页效果 和排序的查询接口！

• mongo.js

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'userlist';

async function connect() {
  // 注意点：由于 MongoClient.connect() 返回的是一个promise对象 因此可以使用async 和 await
  // console.log(MongoClient.connect(url)); //（MongoClient.connect(url) 返回一个Promise对象）
  const client = await MongoClient.connect(url); //链接数据库

  const db = client.db(dbName); //匹配数据库
  return {
    client,
    db
  }
}

//数据库操作之 增函数 参数1：集合 参数2：data数据（增的数据）
function insert(cloName, data) {
  //1:链接数据库 并且把db 和 client在链接数据库中导出 
  let {
    db,
    client
  } = connect()

  //2：添加数据
  // 根据 调用这个函数传入的数据库集合 给对应的集合添加数据
  const collections = db.collections(cloName);
  //需要判断传入的数据 是一条还是多条 一条就是insertOne 多条就是insertMany 在集合之中插入数据 
  const result = collection[Array.isArray(data) ? "insertMany" : "insertOne"](data);

  //3：关闭数据库连接
  client.close();
  return result;
}

//数据库 1：建立链接 2：查询集合（表） 3：

// //查 函数
// 操作数据库的前提是：引入数据库，还有连接网址，连接数据库名称，数据库的链接
// 方法里面：数据库的链接（里面有着：链接数据库 匹配数据库集合，最后根据所选的集合 操作数据库） 最后关闭数据库！
async function find(cloName, query = {}, options = {}) { //参数1：数据库中的集合（表） 参数2：操作的数据库语句 参数3：配置参数 
  //1:链接数据库
  let {
    db,
    client
  } = await connect();
  //2:匹配数据库集合 
  let collection = db.collection(cloName);
  //3：最后根据所选的集合 操作数据库 查询操作
  let result = collection.find(query);

  //分页功能 需要的参数：页数 限制显示的多少页 跳过的数据条数 eg: 1页-0~5-0条 2页-5~10条-5条 3页-10~15-10条
  //01：查询跳过的记录
  if (options.skip) {
    result = result.skip(options.skip) //result.skip()方法 设置跳过记录 
  }
  //02：设置显示的条数
  if (options.limit) {
    result = result.limit(options.limit)
  }
  //排序的功能
  if (options.sort) { //前端传来的之 ["peice"] 或者["price","1"] 第一种为默认的降序 第二种为升序
    let key, val;
    key = options.sort[0]; //拿到key值 
    if (options.sort.length > 1) {
      val = options.sort[1] * 1;
    } else {
      val = -1;
    }
    result = result.sort({ //对象[字符串] 
      [key]: val
    })
  }

  result = await result.toArray(); //返回的是一个数组的形式！给与前端！
  //最后 客户端关闭数据库  
  client.close();
  return result; //返回查询结果 一个promise对象
}

//把增删改查 到出  在引入这个工具函数时候 调用！
module.exports = {
  insert,
  find
}

goods.js

const express = require("express");
const router = express.Router();

const mongo = require("../utils/mongo")

//get 方式查询所有数据 /api/goods 
router.get("/", async (req, res) => {
  //分页效果！
  //设置默认显示的条数还有第几页 并且获取到前端发来的请求参数！
  let {
    //page 第一页 size为显示条数大小为10 sort默认的排序（降） 根据nowPrice排序 注意点：nowPrice一定是数值型！ 不带""
    page = 1, size = 10, sort = "nowPrice"
  } = req.query;
  //设置skip跳过的记录 还有限制显示的那些数据条数
  let skip = (page - 1) * size;
  let limit = size * 1;

  //排序的参数处理
  sort = sort.split(","); //参数传递：price,1等等！  ['price'],['price','-1']

  //find()参数：参数1：数据库中的集合（表） 参数2：操作的数据库语句 参数3：配置参数 
  let result = await mongo.find("goods", {}, {
    skip,
    limit,
    sort
  });

  // 排序传递的参数为：第一个是价格,升序还是降序，需要切割为数组！ => price,1 


  res.send(result);
})

module.exports = router;

增系列

mogon.js

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'userlist';

async function connect() {
  // 注意点：由于 MongoClient.connect() 返回的是一个promise对象 因此可以使用async 和 await
  // console.log(MongoClient.connect(url)); //（MongoClient.connect(url) 返回一个Promise对象）
  const client = await MongoClient.connect(url); //链接数据库

  const db = client.db(dbName); //匹配数据库
  return {
    client,
    db
  }
}

//数据库操作之 增函数 参数1：集合 参数2：data数据（增的数据）
async function insert(colName, data) {
  //1:链接数据库 并且把db 和 client在链接数据库中导出 
  let {
    db,
    client
  } = await connect()

  //2：匹配数据库集合
  const collection = db.collection(colName);
  //3：需要判断传入的数据 是一条还是多条 一条就是insertOne 多条就是insertMany 在集合之中插入数据 
  const result = await collection[Array.isArray(data) ? "insertMany" : "insertOne"](data);

  //3：关闭数据库连接
  client.close();
  return result;
}


//把增删改查 到出  在引入这个工具函数时候 调用！
module.exports = {
  insert,
  find
}

goods.js

const express = require("express");
const router = express.Router();

const mongo = require("../utils/mongo")

//post 方式 增加数据 
router.post("/", async (req, res) => {
  // `db.集合的名称.insertMany([{name:"名称",age:11},{name:"www",age:20}])`

  // insert() 参数1：数据库集合 参数2：插入的数据 插入一条数据的话 直接一个对象 插入多条数据的话 [{},{}] 对象里面书写插入的参数！
  // let result = await mongo.insert("goods2", {
  //   "name": "ppp",
  //   "purchase": "1件起购",
  //   "oldprice": 12345.00,
  // });
  let result = await mongo.insert("goods2", [{
    "name": "ppp",
    "purchase": "1件起购",
    "oldprice": 222,
  }, {
    "name": "lll",
    "purchase": "1件起购",
    "oldprice": 111,
  }]);
  res.send("插入成功");
})

module.exports = router;

删系列

mongo.js

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient,
  ObjectId
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'userlist';

async function connect() {
  // 注意点：由于 MongoClient.connect() 返回的是一个promise对象 因此可以使用async 和 await
  // console.log(MongoClient.connect(url)); //（MongoClient.connect(url) 返回一个Promise对象）
  const client = await MongoClient.connect(url); //链接数据库

  const db = client.db(dbName); //匹配数据库
  return {
    client,
    db
  }
}

//数据库之 删 
// `db.集合的名称.deleteMany({name:"ppp"})`
async function remove(colName, query) {
  //1：链接数据库
  let {
    db,
    client
  } = await connect()
  //根据id删除 数据
  if (query._id && typeof query._id === 'string') {
    query._id = ObjectId(query._id);
  }

  //2：匹配集合
  let collection = db.collection(colName);

  //判断是删除一条还是多条
  let result = await collection.deleteMany(query);
  client.close();
  return result;
}


//把增删改查 到出  在引入这个工具函数时候 调用！
module.exports = {
  insert,
  find,
  remove
}

goods.js

const express = require("express");
const router = express.Router();

const mongo = require("../utils/mongo")

// http://localhost:9292/api/goods/5f2e17442828672250f510ca 验证的时候传递id
router.delete('/:id', async (req, res) => {
  // router.delete('/:name', async (req, res) => {
  const {
    id,
    // name
  } = req.params;
  // console.log("name" + name);

  try {
    const result = await mongo.remove('goods2', {
      _id: id
    })
    // const result = await mongo.remove('goods2', {
    //   name: name
    // })
    res.send('success')
  } catch (err) {
    res.send('fail');
  }

})

module.exports = router;

改系列

mongo.js

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient,
  ObjectId
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'userlist';

async function connect() {
  // 注意点：由于 MongoClient.connect() 返回的是一个promise对象 因此可以使用async 和 await
  // console.log(MongoClient.connect(url)); //（MongoClient.connect(url) 返回一个Promise对象）
  const client = await MongoClient.connect(url); //链接数据库

  const db = client.db(dbName); //匹配数据库
  return {
    client,
    db
  }
}

//数据库之 改
// `db.集合的名称.updateOne( {name:"ppp",age:10 } , { $set : { name:"嘿嘿",age:20} } );`
//根据id来修改 数据库中的data
async function updata(colName, query, newData) { //newData{$set:{price:200,qty:2},$inc:{view:1}}
  let {
    db,
    client
  } = await connect();
  let collection = db.collection(colName);

  //根据id删除 数据
  if (query._id && typeof query._id === 'string') {
    query._id = ObjectId(query._id);
  }

  let result = await collection.updateOne(query, newData);
  console.log("result" + result);
  return result;
}

//把增删改查 到出  在引入这个工具函数时候 调用！
module.exports = {
  insert,
  find,
  remove,
  updata
}

goods.js

根据id修改数据库的数据

const express = require("express");
const router = express.Router();

const mongo = require("../utils/mongo");
const {
  updata
} = require("../utils/mongo");
const {
  query
} = require("express");

//put方式 修改数据
// `db.集合的名称.updateOne( {name:"ppp",age:10 } , { $set : { name:"嘿嘿",age:20} } );`
router.put("/:id", async (req, res) => {
  let {
    id
  } = req.params;
  console.log("id" + id);
  // let whereDate = {
  //   name: "ooo"
  // }
  let whereDate = {
    _id: id
  }
  let updataDate = {
    $set: {
      name: "zzz",
      oldPrice: 200,
    },
    $inc: {
      view: 1
    }
  }
  console.log(whereDate, updataDate); //ok

  try {
    let result = await mongo.updata("goods2", whereDate, updataDate);
    res.send("success");
  } catch (err) {
    res.send("fail")
  }
})

module.exports = router;