mongodb

数据库操作文件

// 引入mongodb
let { MongoClient, ObjectID } = require('mongodb');

// 引入错误对象
let { MESSAGE } = require('../conf');

// 面向对象思想
class DataBase{
    // 构造函数
    constructor(address, databaseName, collectionName) {
        // 地址
        this.address = address;
        // 数据库名称
        this.databaseName = databaseName;
        // 集合名称
        this.collectionName = collectionName;
    }
    // 切换集合的方法
    collection(collectionName) {
        this.collectionName = collectionName;
        // 链式调用
        return this;
    }

    // 连接数据库
    connect() {
        return new Promise((resolve, reject) => {
            // 如果存在db,直接返回,保证只连接一次，提高效率
            if (this.db) {
                return resolve(this.db);
            }
            MongoClient.connect(this.address, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
                if (err) {
                    reject(MESSAGE.databaseError)
                } else {
                    // 存储数据库和客户端
                    this.db = client.db(this.databaseName);
                    this.client = client;
                    resolve(this.db);
                    // 监听程序退出
                    process.on('exit', () => {
                        client.close();
                    })
                    // resolve(client.db(this.databaseName))
                }
            })
        })
    }
    // 插入数据
    insertOne(obj) {
        return new Promise((resolve, reject) => {
            // 连接数据库之后才能操作
            this.connect()
                .then(
                    db => {
                        db.collection(this.collectionName)
                            // 插入
                            .insertOne(obj, (err, data) => {
                                // console.log(err, data)
                                if (err) {
                                    reject(MESSAGE.collectionInsertError)
                                } else if (data.result.n > 0) {
                                    resolve(data.result)
                                } else {
                                    reject(MESSAGE.collectionInsertNoData)
                                }
                            })
                    },
                    err => reject(err)
                )
        })
    }
    // 插入多条数据
    insertMany(arr) {
        // 返回promise
        return new Promise((resolve, reject) => {
            // 连接数据库
            this.connect()
                .then(
                    db => {
                        // 向数据库中插入多条数据
                        db.collection(this.collectionName)
                            .insertMany(arr, (err, data) => {
                                if (err) {
                                    reject(MESSAGE.collectionInsertError)
                                } else if (data.result.n > 0) {
                                    // 插入成功
                                    resolve(data.result)
                                } else {
                                    // 没有插入数据
                                    reject(MESSAGE.collectionInsertNoData)
                                }
                            })
                    },
                    err => reject(err)
                )
        })
    }

    // 删除数据
    deleteOne(obj) {
        // 返回promise
        return new Promise((resolve, reject) => {
            // 连接数据库
            this.connect()
                .then(
                    db => {
                        // 操作集合
                        db.collection(this.collectionName)
                            .deleteOne(obj, (err, data) => {
                                if (err) {
                                    reject(MESSAGE.collectionDeleteError)
                                } else if (data.result.n > 0) {
                                    resolve(data.result)
                                } else {
                                    reject(MESSAGE.collectionDeleteNoData)
                                }
                            })
                    },
                    err => reject(err)
                )
        })
    }

    // 删除多条
    deleteMany(arr) {
        // 多个操作
        return Promise.all(arr.map(item => this.deleteOne(item)))
    }

    // 修改数据
    updateOne(oldObj, newObj) {
        return new Promise((resolve, reject) => {
            // 连接数据库
            this.connect()
                .then(
                    db => {
                        // 获取集合
                        db.collection(this.collectionName)
                            // 更新操作
                            .updateOne(oldObj, { $set: newObj }, (err, data) => {
                                if (err) {
                                    reject(MESSAGE.collectionUpdateError)
                                } else if (data.result.n >0) {
                                    resolve(data.result)
                                } else {
                                    reject(MESSAGE.collectionUpdateNoData)
                                }
                            })
                    },
                    err => reject(err)
                )
        })
    }
    // 更新多条数据
    updateMany(arr) {
        return Promise.all(arr.map(item => this.updateOne(...item)))
    }

    // 查询数据
    findOne(obj) {
        return new Promise((resolve, reject) => {
            this.connect()
                .then(
                    db => {
                        // 如果有id
                        if (obj._id) {
                            obj._id = ObjectID(obj._id)
                        }
                        // 获取集合
                        db.collection(this.collectionName)
                            .findOne(obj, (err, data) => {
                                if (err) {
                                    reject(MESSAGE.collectionFindError)
                                } else if (data) {
                                    resolve(data)
                                } else {
                                    reject(MESSAGE.collectionFindNoData)
                                }
                            })
                    },
                    err => reject(err)
                )
        })
    }

    // 查询多条
    findMany(obj, fn = data => data) {
        return new Promise((resolve, reject) => {
            this.connect()
                .then(
                    db => {
                        let result = db.collection(this.collectionName).find(obj);
                        // 用回调函数处理查询的结果，处理完再转成数组
                        fn(result)
                            // 通过toArray可以将数据转为数组
                            .toArray((err, data) => {
                                // console.log(err, data);
                                if (err) {
                                    reject(MESSAGE.collectionFindError)
                                } else if (data.length) {
                                    resolve(data)
                                } else {
                                    reject(MESSAGE.collectionFindNoData)
                                }
                            })
                    },
                    err => reject(err)
                )
        })
    }

}

module.exports = DataBase

## 配置文件

```javascript
// 暴露接口
module.exports = {
    // 数据库地址
    MONGO_URL: 'mongodb://localhost:27017',
    // 数据库名称
    MONGO_NAME: 'test_vue',
    // 返回的消息
    MESSAGE: {
        databaseError: { errno: 1, msg: '数据库连接错误' },
        collectionInsertError: { errno: 2, msg: '数据库插入错误' },
        collectionInsertNoData: { errno: 3, msg: '数据库没有插入权限' },
        // 删除错误
        collectionDeleteError: { errno: 4, msg: '数据库删除错误' },
        collectionDeleteNoData: { errno: 5, msg: '数据库没有删除数据' },
        // 更新错误
        collectionUpdateError: { errno: 6, msg: '数据库数据更新失败' },
        collectionUpdateNoData: { errno: 7, msg: '数据库没有更新数据' },
        // 查询错误
        collectionFindError: { errno: 8, msg: '查询错误' },
        collectionFindNoData: { errno: 9, msg: '没有查询到数据' },
        // 登录
        loginError: { errno: 10, msg: '用户名或者密码错误' },
        notLogin: { errno: 11, msg: '没有登录' },
    }
}

```javascript
// 引入数据库
let { db, MESSAGE } = require('../../tools');

module.exports = (req, res) => {
    // 数据在请求体上
    // console.log(req.body);
    // res.json(123)
    // 插入数据
    // db.collection('manager').insertOne({ username: 'admin', password: 'a123' })
    // 查询集合
    db.collection('manager').findOne(req.body)
        .then(
            data => {
                // console.log(data);
                // session登录，在session中记录用户登录信息
                req.session.username = data.username;
                // 返回结果
                res.json({ errno: 0, data: data.username })
            },
            err => {
                // 用户名或者密码错误
                if (err.errno === 9) {
                    return res.json(MESSAGE.loginError);
                } else {
                    // 其它错误
                    res.json(err);
                }
            }
        )
}