Node.js进修之路23——Node.js应用mongoose衔接mongodb数据库

2024年3月28日 198次阅读 来源: Karuru

Node.js应用mongoose衔接mongodb数据库

Node.js衔接
mongodb数据库有许多种要领，经由过程
mongoose模块引入是个中的一个要领

  • 代码构造构造
|---|根目录
|---|---|connect.js(mongoose测试衔接)
|---|---|user.js(定义user数据表)
|---|---|operate.js(定义mongodb的增编削查功用)
|---|---|login.js(Node背景挪用operate.js文件的要领处置惩罚数据)

1. 引入mongoose测试衔接

当前运用的
mongoose版本为
4.13.7

  • 该文件为connect.js

1.1 代码部份

const mongoose = require("mongoose");
const DB_URL = "mongodb://127.0.0.1:27017/infos";
mongoose.Promise = global.Promise;
mongoose.connect(DB_URL, { useMongoClient: true });
mongoose.connection.on("connected", () => {
    console.log("mongodb数据库衔接胜利")
});
mongoose.connection.on("error", (error) => {
    console.log("mongodb数据库衔接失利", error)
});
module.exports = mongoose;

1.2 代码剖析

1.2.1 引入mongoose模块

  • const mongoose = require("mongoose");

1.2.2 猎取mongodb的本机地点

  • const DB_URL = "mongodb://127.0.0.1:27017/infos";
  • 127.0.0.1是当地IP地点
  • 27017是mongodb的效劳启动端口

  • infos是mongodb的一个数据鸠合名字

    • mongodb能够有许多数据鸠合，每一个鸠合中能够有许多数据表。
    • 类比一下：你有一个巨型泊车场(mongodb)，里边分了差别的泊车区(鸠合，这里的infos)，每一个泊车区能够停许多车((下文提到的user)，相当于每一个数据鸠合里边能够有许多张数据表)。

  • 假如须要给mongodb加上用户及暗码，能够如许

    • const DB_URL = "mongodb://username:password@127.0.0.1:27017/infos";
    • 个中username为用户名，中心英文:，password为暗码，其他稳定

1.2.3 衔接数据库胜利

  • mongoose.connection.on("connected", callback())
  • 数据库衔接胜利后，会在控制台输出mongodb数据库衔接胜利

1.2.4 衔接数据库失利

  • mongoose.connection.on("error", callback())
  • 数据库衔接胜利后，会在控制台输出mongodb数据库衔接失利和错误信息

1.2.5 导出mongoose模块

  • module.exports = mongoose;

2. 定义每张数据表的字段

  • 该文件为user.js

2.1 代码引见

const mongoose = require('mongoose');
const db = require('./connect.js');
const userSchema = new mongoose.Schema({
    number: { type: Number},
    email: { type: String },
    password: { type: String },
    rePassword: { type: String },
    mobile: { type: String },
    question: { type: String },
    answer: { type: String },
});
let userModel = db.model('user', userSchema);
module.exports = userModel;

2.2 代码剖析

2.2.1 引入mongoose模块

  • const mongoose = require("mongoose");

2.2.1 引入衔接mongodb数据库的模块

  • const db = require('./connect.js');

2.2.2 定义Schema

  • const userSchema = new mongoose.Schema({})
  • 经由过程mongoose对象的Schema属性建立一个Schema对象

Schema原意为
架构

在
mongodb中，每一个数据字段都要有牢固的数据类型，所以
Schema在
mongoose中的意义为，每一张数据表对应的字段的数据类型

  • Schema所能够具有的数据类型有以下几个

    • String
    • Number
    • Date
    • Buffer
    • Boolean
    • Mixed
    • ObjectId
    • Array

  • 字段引见，以number字段为例

    • type是该字段的数据类型
    • default是该字段的默认值
    • 另有许多其他的属性，以及能够自定义属性

2.2.3 确认数据表和该数据表的字段

  • let userModel = db.model('user', userSchema);
  • 定义一个数据表userModel
  • 运用db.model要领，第一个参数是数据表的名字，第二个参数是该数据表运用的Schema

2.2.4 终究导出定义的数据表

  • module.exports = userModel;
  • 导出以后，在operate.js中运用这个对象的mongodb的增编削查要领

3. 定义mongodb的增编削查功用

3.1 代码部份

  • 该文件为operate.js
let userModel = require('./user.js');
module.exports = {
    save(data) {
        return new Promise((resolve, reject) => {
            userModel.create(data, (err, docs) => {
                if (err) {
                    rejct(err);
                } else {
                    resolve(docs);
                }
            })
        })
    },
    find(data = {}, fields = null, options = {}) {
        return new Promise((resolve, reject) => {
            //model.find(须要查找的对象(假如为空，则查找到一切数据), 属性过滤对象[可选参数], options[可选参数], callback)
            userModel.find(data, fields, options, (error, doc) => {
                if (error) {
                    reject(error)
                } else {
                    resolve(doc)
                }
            })
        })
    },
    findOne(data) {
        return new Promise((resolve, reject) => {
            //model.findOne(须要查找的对象,callback)
            userModel.findOne(data, (error, doc) => {
                if (error) {
                    reject(error)
                } else {
                    resolve(doc)
                }
            })
        })
    },
    findById(data) {
        return new Promise((resolve, reject) => {
            //model.findById(须要查找的id对象 ,callback)
            userModel.findById(data, (error, doc) => {
                if (error) {
                    reject(error)
                } else {
                    resolve(doc)
                }
            })
        })
    },
    update(conditions, update) {
        return new Promise((resolve, reject) => {
            //model.update(查询前提,更新对象,callback)
            userModel.update(conditions, update, (error, doc) => {
                if (error) {
                    reject(error)
                } else {
                    resolve(doc)
                }
            })
        })
    },
    remove(conditions) {
        return new Promise((resolve, reject) => {
            //model.update(查询前提,callback)
            userModel.remove(conditions, (error, doc) => {
                if (error) {
                    reject(error)
                } else {
                    resolve(doc)
                }
            })
        })
    }
};

3.2 代码剖析

  • 引入user模块
  • let userModel = require('../models/users');
  • 引入该文件的目标是，让userModel这个数据表直接的挪用mongodb的种种要领

4. 背景直接运用operate处置惩罚数据

  • 该文件为login.js

4.1 代码部份

const express = require('express');
const router = express.Router();
let operate = require('./operate');
router.post('/', function (req, res, next) {
    let param = {};
    param.email = req.body.email;
    param.password = req.body.password;
    console.log(param);
    operate.save(param).then(result => {
        if (result) {
            res.json({
                data: result,
                success: true
            })
        } else {
            res.json({
                data: result,
                success: false
            })
        }
    });
});
module.exports = router;

4.2 代码剖析

  • 须要闇练运用Express的router要领
  • 引入Express，定义一个post要领
  • post要领通报的对象数据挂在在req.body上
  • 直接挪用operate.save()要领，通报param对象参数
  • 猎取到返回效果result，对猎取到的效果举行进一步处置惩罚
    原文作者：Karuru
    原文地址: https://segmentfault.com/a/1190000013465661
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞