1.MongoDB 概述

MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写，旨在为 Web 应用提供可扩展的高性能数据存储解决方案。
MongoDB 使用集合（collection）和文档（document）来描述和存储数据，集合（collection）就相当于表，文档（document）相当于行，字段相当于列，不像MySQL之类的关系型数据库，表结构是固定的，比如某一行由若干列组成，行行都一样，而 MongoDB 不同，一个集合里的多个文档可以有不同的结构，更灵活一些。
MongoDB 有自己很鲜明的特色，总结起来有以下 4 条：
1. 没有表结构的限制
传统 SQL 数据库中，对每张表都需要定义表结构。如果有新的存储需求，往往需要添加新的字段，更改表结构。在一些场景下，会显得很不方便。
而对于 MongoDB，这不再是问题。因为它没有表结构这个概念，在使用一张表之前，不需要对这张表进行任何初始化操作。MongoDB 的这种特性对快捷开发和多变的业务需求是很合适的。
2. 完全的索引支持
有些 NoSQL 数据库，比如 Redis，它是内存数据库，速度很快。但是，做为键值数据库，只支持一种按键查询的方式。灵活性、使用范围和易用性都受到影响。再比如 HBase，写入速度很快。但是，同样查询受限，它只支持单索引，二级索引需要自己实现。
而 MongoDB 支持单键索引、多键索引、全文索引和地理位置索引。所以 MongoDB 是功能非常完善的 NoSQL 数据库，也被称为最接近关系数据库的非关系数据库。
3. 良好的数据安全性和方便的规模扩展
MongoDB 使用复制集做多副本存储，以保证数据的安全性。
同时，MongoDB 内置的分片技术可以很方便地进行数据规模的扩展。分片技术是很新颖的一个特性，它包含了自动数据接口，动态扩容和缩容等一系列在其他数据库中需要大量人工操作的工作，同时提供了对数据库的统一访问入口，不需要在应用层再进行分发，显著减少了人工成本。
4. 完善的文档支持和驱动支持

2.MongoDB 安装

MongoDB官网下载地址：https://www.mongodb.com/try/download/community

  • db：和mysql的概念一致
  • collection：集合，类似于mysql中的表
  • document：每个集合中的文档，类似于mysql中的记录
    • Primary Key：和mysql中的主键含义一致，每个document都有一个主键
    • field：文档中的字段

mongodb属于nosql中的文档型数据库，每个文档相当于是一个对象，它没有列的概念，也没有表关系
由于它是一个nosql数据库：

  • 无sql语句
  • 使用极其简单，学习成本非常低
  • 由于没有集合之间的关联，难以表达复杂的数据关系
  • 存取速度极快

由于它是一个文档型数据库：

  • 数据内容非常丰富和灵活
  • 对数据结构难以进行有效的限制

    2.1可视化工具 Robo 3T

    我们可以在 Robo 3T 的官网上下载到该软件，官网地址为：https://robomongo.org/
    图标是为：
    image.png

3.在vscode中操作

3.1mongoose 安装

使用 mongoose 首先需要保证已经安装好 node.js 和 mongodb。然后在项目根目录中通过以下命令安装 mongoose：

  1. npm install mongoose

3.2连接 mongodb

这里使用学生和老师的管理系统作为例子解释：
安装好 mongoose 后，就可以在项目中通过 mongoose 提供的方法将项目与 mongodb 连接起来。代码如下：

  1. //schoolconnect.js
  2. let mongoose=require("mongoose");//引用mongoose的包
  3. const studentURI = "mongodb://localhost:27017/school"; //找到本地的数据库
  4. mongoose.connect(studentURI); //链接本地的数据库
  5. mongoose.connection.on("connected",()=>{//判断是否链接成功，成功就是进入该箭头函数
  6.     console.log("学校链接已打开");
  7. })

3.3建立班级和学生的Schema

Schema 是 mongoose 提供的一个方法，用来定义 mongodb 中对应的数据集合的结构。
这里是根据需求可以建立适合数量的Schema，之后将形成对应数量的module
学生的Schema如下：

  1. //studentSchema.js
  2. // 学生的信息规范
  3. const mongoose = require("mongoose");
  4. const Schema = mongoose.Schema;//引用mongoose里的Schema
  5. const educationTypes = require("./studenteducation");//引入学生学历
  7. let studentsSchema = new Schema({
  8.     studentNum: {
  9.         type: String,
  10.         index: true,//下标
  11.         unique: true,//唯一性
  12.         minlength: 1,//最小数
  13.         maxlength: 6,//最大值
  14.         trim: true,//左右空格
  15.         required:true//必填
  16.     },
  17.     studentName: {
  18.         type: String,
  19.         required: true,
  20.         trim: true,
  21.         select: false,//当被选中时 不显示出来
  22.         minlength: 2,
  23.         maxlength: 10,
  24.     },
  25.     tel: {
  26.         type: Number,
  27.         required: true,
  28.         trim: true,
  29.         minlength: 11,
  30.         maxlength: 11,
  31.     },
  32.     birthday:{
  33.         type:Date,
  34.         default:Date.now,//现在的时间
  35.     },
  36.     education:{
  37.         type:String,
  38.         enum:educationTypes,//学历选择
  39.     },
  41.     classid: {
  42.         type:Schema.Types.ObjectId,//与班级信息链接
  43.         required:true,
  44.         ref:"classModel" //要进行关联查询是引入关联的UserModel的名字,该名字是导出model的第一个参数的名字
  45.     },
  46. }, { versionKey: false });
  48. module.exports = mongoose.model("studentModel",studentsSchema,"student");
  49. // - "studentModel"：数据模型名称
  50. // - studentsSchema 数据结构
  51. // - "users"：数据模型对应的数据库中的数据集合名称

老师的Schema如下：

  1. // 班级的信息规范
  2. const mongoose = require("mongoose");
  3. const Schema = mongoose.Schema;
  5. let classSchema = new Schema({
  6.     className:{
  7.         type:String,
  8.         required:true,
  9.         minlength: 3,
  10.         maxlength: 5,
  11.     },
  12.     classType:{
  13.         type:String,
  14.         required:true,
  15.         default:"火箭班"
  16.     },
  17.     classTeacher:{
  18.         type:String,
  19.     },
  20. });
  21. module.exports = mongoose.model("classModel",classSchema,"class");
  1. //studenteducation.js
  3. module.exports=["大专", "本科", "研究生", "博士"];
  1. //index.js
  3. // 最终被外层dao使用
  4. require("./schoolconnect");
  5. let studentSchema= require("./studentSchema");
  6. let teacherSchema= require("./teacherSchema");
  8. module.exports.studentSchema=studentSchema;
  9. module.exports.teacherSchema=teacherSchema;

Dao

  1. //studentsDao.js
  3. let { studentSchema } = require("../models/index");
  5. // 添加
  6. async function studentAdd(dogs) {
  7.     let result = await studentSchema.insertMany(dogs);
  8.     return result;
  9. }
  11. // 查找
  12. async function find() {
  13.     let result = await studentSchema.find();
  14.     return result;
  15. }
  17. // 修改
  18. async function studentupdate(id,dogs) {
  19.     let result = await studentSchema.updateMany({_id:id},dogs);//?????({_id:id}
  20.     return result;
  21. }
  22. // 删除
  23. async function studentremove(id) {
  24.     let result = await studentSchema.remove({_id:id});
  25.     return result;
  26. }
  28. async function query(filter,page,limit = 5){
  29.     //分页公式 (page-1)*limit
  30.     let result = await studentSchema.find(filter).skip((page-1)*limit).limit(limit);
  31.     return result;
  32. }
  35. async function teacherpopulate(){
  36.     let result = await studentSchema
  37.         .find().populate("classid","classType classTeacher");
  38.     return result;
  39. }  
  42. module.exports.teacherpopulate = teacherpopulate;
  43. module.exports.studentAdd = studentAdd;
  44. module.exports.find = find;
  45. module.exports.studentupdate = studentupdate;
  46. module.exports.studentremove = studentremove;
  47. module.exports.query = query;
  1. //teacherDao.js
  2. let { teacherSchema } = require("../models/index");
  4. // 添加
  5. async function teacherAdd(dogs) {
  6.     let result = await teacherSchema.insertMany(dogs);
  7.     return result;
  8. }
  10. // 查找
  11. async function find() {
  12.     let result = await teacherSchema.find();
  13.     return result;
  14. }
  16. // 修改
  17. async function teacherupdate(id,dogs) {
  18.     let result = await teacherSchema.updateMany({_id:id},dogs);//?????({_id:id}
  19.     return result;
  20. }
  21. // 删除
  22. async function teacherremove(id) {
  23.     let result = await teacherSchema.remove({_id:id});
  24.     return result;
  25. }
  28. module.exports.teacherAdd = teacherAdd;
  29. module.exports.find = find;
  30. module.exports.teacherupdate = teacherupdate;
  31. module.exports.teacherremove = teacherremove;

outside

  1. let studentsDao=require("./dao/studentsDao");
  2. let teacherDao=require("./dao/teacherDao");
  3. let studentsdata=require("./Mock/studentsMock");
  4. let teacherMock=require("./Mock/teacherMock");
  6. // console.log(studentsdata);
  7. // 添加学生
  8. // studentsDao.studentAdd(studentsdata).then(data => {
  9. //     console.log(data);
  10. // })
  11. // 添加班级
  12. // teacherDao.teacherAdd(teacherMock).then(data => {
  13. //     console.log(data);
  14. // })
  16. // 查找学生
  17. // studentsDao.find().then(data => {
  18. //     console.log(data);
  19. // })
  21. // 删除学生
  22. // studentsDao.studentremove("624560e79f76a885cffcc1a7").then(data => {
  23. //     console.log(data);
  24. // })
  26. // 修改学生
  27. // studentsDao.studentupdate("624560e79f76a885cffcc1a8", {
  28. //     "education" : "大专",
  29. // }).then(data => {
  30. //     console.log(data);
  31. // })
  36. // 查找老师
  37. // teacherDao.find().then(data => {
  38. //     console.log(data);
  39. // })
  41. // 删除老师
  42. // teacherDao.teacherremove("6245633e5b525cdff21827eb").then(data => {
  43. //     console.log(data);
  44. // })
  46. // 修改老师
  47. // teacherDao.teacherupdate("6245633e5b525cdff21827e8", {
  48. //     "classType" : "平行班",
  49. // }).then(data => {
  50. //     console.log(data);
  51. // })
  53. // 分页查询
  54. // studentsDao.query({},1,1).then((data) => {
  55. //   console.log(data);
  56. // })
  58. studentsDao.teacherpopulate().then((data) => {
  59.   console.log(data);
  60. })
  1. //studentsMock.js
  2. let Mock = require("mockjs");
  3. let students = Mock.mock({
  4.     "dates|20-25": [{
  5.         "studentNum":"@word(1,6)" ,
  6.         "studentName|1": "@cname",
  7.         "tel": /^1([358][0-9]|4[579]|66|7[0135678]|9[89])[0-9]{8}$/,
  8.         "education|1": ['@pick(["大专","本科","研究生","博士"])'],
  9.         "classid":"@word(3,9)",
  10.     }]
  11. }).dates;
  13. module.exports = students;
  15. //teacherMock.js
  17. let Mock = require("mockjs");
  18. let teachers = Mock.mock({
  19.     "dates|3-5": [{
  20.         "className":"@word(1,6)" ,
  21.         "classTeacher":"@cname",
  22.     }]
  23. }).dates;
  25. module.exports = teachers;