② nodejs + mongodb 搭建服务器

搭建本地服务器

1. 引入第三方模块 express

2. 利用 express 创建一个服务器

3. 搭建静态资源服务器

4. 引入路由总中间件

5. 使用路由总中间件

6. 监听服务器开启

• server.js

    // 001 引入第三方模块
    const express = require('express');

    // 002 利用express创建一个服务器
    const app = express();
    // 003 搭建静态资源服务器
    app.use(express.static('/'))

    const { PORT } = require('./config.json');

    // 004 引入路由总中间件
    const allRouter = require('./routers');
    // 005 使用路由总中间件
    app.use(allRouter);

    // 006 监听服务器开启
    app.listen(PORT, () => {
        console.log(`Server is running on port ${PORT}`);
    })

配置请求路径

• router/index.js

    const express = require('express');
    let Router = express.Router();

    let loginRouter = require('./login');
    let goodsRouter = require('./goods');
    let userRouter = require('./user');
    let regRouter = require('./reg');
    
    Router.use(express.json(), express.urlencoded({ extended: true }));
    Router.use('./login', loginRouter);
    Router.use('./goods', goodsRouter);
    Router.use('./user', userRouter);
    Router.use('./reg', regRouter);
    
    module.exports = Router;

统一前后端的数据格式

• utils/index.js

    // 解构默认值
    function formatData({status = 200, data = [], msg = '操作成功'} = {}) {
        if(status === 0) {
            msg = "fail";
        } 
        return {
            status,
            data,
            msg
        }
    }
    module.exports = {
        formatData
    }

连接数据库

• src/db/mongodb.js -- 初版

    const { MongoClient } = require('mongodb');
    
    const { dbUrl, dbName } = require('../config.json');

    // 连接MongoDB数据库
    async function connect() {
        const client = await MongoClient.connect(dbUrl);
        const db = client.db(dbName);
        return {
            client,
            db
        }
    }
    
    /**
     * 增 -- 注册
     * @param {String} colName 集合名称
     * @param {Array|Object} data 插入的数据
     * return {Object} 返回写入的结果
     */
     async function create(coleName, data) {
         const { db, client } = await connect();
         let collection = db.collection(colName);
         
         // 判断传入的Data是否为数组
         if(!Array.isArray(data)) {
             data = [data]
         }
         let result = await collection.insertMany(data);
         client.close();
         return result;
     }
     
    /**
     * 删除
     * @param {String} colName 集合名称
     * @param {Object} query 查询条件
    */
    async function remove(colName, query) {
        const { db, client } = await connect();
        let collection = db.collection(colName);
        let result = await collection.deleteMany(query);
        client.close();
        return result;
    }
    
    /**
     * 更新
     * @param {String} colName 集合名称
     * @param {Object} query 查询条件
     * @param {Object} data 更新字段数据
    */
    async function update(colName, query, data) {
        const { db, client } = await connect();
        let collection = db.collection(colName);
        let result = await collection.updateMany(query, { $set: data });
        client.close();
        return result;
    }

    /**
     * 查
     * @param {String} colName 集合名称
     * @param {Object} query 查询条件
    */
    async function find(colName, query) {
        const { db, client } = await connect();
        let collection = db.collection(colName);
        // promise对象--.toArray()才能拿到结果
        let result = await collection.find(query).toArray();
        client.close();
        return result;
    }
    
    // 模块开发思想--导出模块
    module.exports = {
        create,
        remove,
        update,
        find
    }

• 增强版查找 --查询条件

    /**
     * 查
     * @param {String} colName 集合名称
     * @param {Object} query 查询条件
    */
    async function find(colName, query) {
        const { db, client } = await connect();
        let collection = db.collection(colName);
        // 处理id查询 {_id: 'xxx'} -> {_id: ObjectId('xxx')}
        if(query._id && typeof query._id === 'string') {
            query._id = Object(query._id);
        }
        // promise对象--.toArray()才能拿到结果
        let result = await collection.find(query).toArray();
        client.close();
        return result;
    }

• 增强版查找--过滤

    /**
     * 查
     * @param {String} colName 集合名称
     * @param {Object} query 查询条件
     * @param   fields 过滤字段
    */
    async function find(colName, query = {}, { fields } = {}) {
        const { db, client } = await connect();
        let collection = db.collection(colName);
        if(query._id && typeof query._id === 'string') {
            query._id = Object(query._id);
        }
        // promise对象--.toArray()才能拿到结果
        let result = await collection.find(query, { fields }).toArray();
        client.close();
        return result;
    }

请求路径模块--方法编写

• user.js

const express = require('express');
const Router = express.Router();
const { find, remove, update } = require('../db/mongodb');
const { formatData } = require('../utils');
const colName = 'user';

// 查询所有用户
Router.get('/', async (req, res) => {
    // 查询数据库
    let result = await find(colName); 
    res.send(formatData({ data: result }))
})
// 查询单个用户信息
Router.get('/:id', async (req, res) => {
    let { id } = req.params;
    let result = await find(colName, { _id: id }, { fields: { password: false, _id: false }});
    res.send(formatData({ data: result }));
})
// 删除用户
Router.delete('/:id', async (req, res) => {
    let { id } = req.params;
    let result = await remove(colName, { _id: id });
    if(result.deleteCount > 0) {
        res.send(formatData());
    } else {
        res.send(formateData({ status: 0 }));
    }
})
// 修改用户信息
Router.patch('/:id', async (req, res) => {
    let {id} = req.params;
    let {password, age, gender} = req.body;
    let result = await update(colName, { _id: id }, { password, age, gender });
    if(result.modifiedCound > 0) {
        res.send(formatData());
    } else {
        res.send(formateData({ status: 0 }));
    }
})

module.exports = Router;

实现分页

• mongodb.js

     /**
     * 查
     * @param {String} colName 集合名称
     * @param {Object} query 查询条件
     * @param   dptions 可选参数
    */
    async function find(colName, query = {}, options = {}) {
        // fields: 用于过滤某些字段
        let { fields: attr, skip, limit, sort } = options;
        const { db, client } = await connect();
        
        let collection = db.collection(colName);
        
        if(query._id && typeof query._id === 'string') {
            query._id = Object(query._id);
        }
        // promise对象--.toArray()才能拿到结果
        let result = await collection.find(query, { attr });
        
        // 跳过数量
        if(skip) {
            result = result.skip(skip);
        }
        // 限制数量
        if(limit) {
            result = result.limit(limit * 1);
        }
        // 排序 1-->升序   -1-->降序
        if(sort) {
            let arr = sort.split(',')
            let key = arr[0];
            let value = arr[1] ? arr[1] * 1 : -1;
            
            result = result.sort({
                [key]: value
            })
        }
        client.close();
        return result;
    }

• goods.js

    // 编写接口数据
    const colName = 'goods';
    // 查询所有商品
    Router.get('/', async (req, res) => {
        let { page =1, size = 10, sort } = req.query;
        let index = (page - 1) * size;
        let data = await mongodb.find(colName, {}, { skip: index, limit: size, sort });
        res.send(formatData({ data }));
    })