Mongoose

• Mongoose是Nodejs的一个模块，这个模块可以操作MongoDB模块对数据库的操作
• Mongooose是一个对象文档模型（ODM）库，它对Node原生的MongoDB模块进一步的优化封装，并提供了更多的功能。

1. Mongoose的好处

• 可以为文档创建一个模式结构（约束）（Schema）
• 可以对模型中的对象/文档进行验证
• 数据可以通过类型转换为对象模型
• 可以使用中间件来应用业务逻辑挂钩
• 比Node原生的MongoDB驱动更容易

2. 新的对象

• mongosoe中为我们提供了几个新的对象

1. Schema（模式对象）

• Schema对象定义约束了数据库中的文档结构

2. Model

• Model对象作为集合中的所有文档的表示，相当于MongoDB数据库中的集合collection

3. Document

• Document表示集合中的具体文档，相当于集合中的一个具体的文档

Mongoose的初次使用

1.下载安装Mongoose
  yarn add mongoose
2.引入mongoose
  const mongoose = require("mongoose")
3.连接MongoDB数据库
  mongoose.connect('mongodb://数据库ip地址:端口号/数据库名',回调)
    回调会给你两个参数 第一个是err就是连接失败的消息，第二个参数是db
    如果端口号是默认端口号(27017) 则可以省略不写
4.断开数据库连接(一般不需要调用)
  mongoose.disconnect()

监听MongoDB数据库的连接状态
  在mongoose对象中有一个属性叫做connection，该对象表示的就是数据库连接
    通过监视该对象的状态，可以来监听数据库的连接与断开
  数据库连接成功的事件
    mongoose.connection.once("open", function() {})
  数据库断开的事件
    mongoose.connection.once("close", function() {})

向集合中插入文档

  const mongoose = require('mongoose')
  mongoose.connect('mongodb://127.0.0.1/mongoose_test', (err, db)=> {
    if(err) {
      console.error(err);
      return 0;
    }else {
      console.log('Connected correctly to server');
    }
  })

  mongoose.connection.once("open", ()=> {
    console.log('数据库连接成功~~')
  })
  const Schema = mongoose.Schema;
  //创建Schema（模式）对象
  const stuSchema = new Schema({
    name: String,
    age: Number,
    gender: {
      type: String,
      default: "female"
    },
    address: String
  })

  // 通过Schema来创建Model
  // Model代表的是数据库中的集合，通过Model才能对数据库进行操作
  // mongoose.model(modelName, schema)
  // modelName 就是要映射的集合名 mongoose会自动将集合名变成复数
  let StuModel = mongoose.model('student', stuSchema)

  // 向数据库中插入一个文档
  StuModel.create({
    name: "权权权",
    age: 17,
    gender: "male",
    address: "湖北黄石"
  }, (err)=> {
    if (!err) {
      console.log('插入成功！！')
    }
  })

• 有了Model 我们就可以来对数据库进行增删改查的操作了

创建

  Model.create(doc(s), [callback])
      用来创建一个或多个文档并添加到数据库中
      参数：
        doc(s) 可以是一个文档对象，也可以是一个文档对象的数组
        callback 当操作完成以后调用的回调函数
      例子
        StuModel.create({
          name: "张三",
          age: 20,
          gender: "male",
          address: "湖北黄石"
        },(err, doc)=> {
          if(!err) {
            console.log(doc)
          }
        })

查询

  Model.find(conditions, [projection], [options], callback)
    查询所有符合条件的文档 总会返回一个数组
  Model.findOne([conditions], [projection], [options], callback)
    查询符合条件的第一个文档，总会返回一个具体的文档对象
  Model.findById(id, [projection], [options], callback)
    根据文档的id属性查询文档
  
   conditions 查询的条件
   projection 投影（需要获取到的字段）
     两种方式
      { name: 1, _id: 0 }
      "name -_id"
   options 查询选项（skip,limit）
     { skip: 3, limit: 1 }
   callback 回调函数，查询结果会通过回调函数返回
    回调函数必须传，如果不传回调函数，压根就不会查询，因为结果会返回给回调函数的两个参数里（err和doc）
  例子
    StuModel.find({}, "name _id" , { skip: 2, limit: 10}, (err, doc)=> {
      if(!err) {
        console.log(doc)
      }
    })

修改

  Model.update(conditions, doc, [options], callback)
  Model.updateMany(conditions, doc, [options], callback)
  Model.updateOne(conditions, doc, [options], callback)
    用来修改一个文档或多个文档
    参数：
      conditions 查询条件
      doc 修改后的对象
      options 配置参数
      callback 回调函数
  Model.replaceOne(conditions, doc, [options], callback)
    例子// 修改唐僧的年龄为20
    StuModel.updateOne({ name: "唐僧"},{$set: {age: 20}}, (err)=> {
      if(!err) {
        console.log("修改成功")
      }
    })

查询文档个数

  Model.count(conditions, callback)
  例子：查询集合文档的个数
    StuModel.count({}, (err,doc)=> {
      if(!err) {
        console.log(doc)
      }
    })

Document对象

• Document 和 集合中的文档一一对应，通过Model查询到的结果都是document

  const StuModel = mongoose.model('student', StuSchema);
  // 创建一个Document
  let stu = new StuModel({
    name: "HBQ",
    age: 20,
    gender: "男",
    address: "武汉"
  })
  stu.save()

Document的一些API

  Model#save()
    保存（存储到数据库）
    例子 创建一个Document并存到数据库中
      let stu = new StuModel({
        name: "HBQ",
        age: 20,
        gender: "男",
        address: "武汉"
      })
    stu.save()
  Model#update(update, [callback])
    更新该实例属性
      例子：更新第一个文档的name为李四
        Model.findOne({}, (err, doc)=> {
          if(!err)
            doc.update({$set: { name: "李四"}}, (err)=> {
              if(!err)
                console.log("更新成功！")
            })
        })
  Model#remove(callback)
    例子 删除第一个文档
      Model.findOne({name: "张三"}, (err, doc)=> {
        if(!err)
          doc.remove((err)=> {
            if(!err)
              console.log("删除成功！")
          })
       })
  Model#get(name)
    获取文档中的指定属性值
      例子 { _id: 0001, name: "张三", age: 20, gender: "男"}
        doc.get("name") ==> 张三  === doc.name
  Model#set(name, value)
    设置文档的指定的属性值
      doc.set("name", "李四") ==> { _id: 0001, name: "张三", age: 20, gender: "男"} === doc.name = "李四"
  Model#toObject()
    将Document对象转换为一个普通的JS对象
      转换为普通的JS对象以后，注意所有的Document对象的方法或属性都不能使用了

模块化

• 需求：我们要对Student集合进行操作（使用模块化）
• 思路：首先是拆分模块 操作数据库需要 连接、创建Schema约束、Mode模型
• 分析得出 拆出两个模块 第一个模块是连接 第二个模块是创建Schema约束并暴露Mode模型

  // 连接数据库模块
  const mongoose = require('mongoose');
  mongoose.connect("mongodb://127.0.0.1/mongoose_test", (err)=> {
    err ? console.log(err) : console.log("数据库连接成功")
  })

  // Model 模块
  const mongoose = require('mongoose');

  let Schema = mongoose.Schema;
  const StuSchema = new Schema({
    name: String,
    age: Number,
    gender: {
      type: String,
      default: "female"
    },
    address: String
  })

  module.exports = mongoose.model('students', StuSchema)

  // 主文件
  require('./conn_mongo') // 引入连接数据库模块
  const Student = require('./models/student') // 引入操作集合
  // 操作集合
  Student.find({}, (err, doc)=> {
    err ? console.log(err) : console.log(doc)
  })