MongoDB

• MongoDB 的特点：数据分层管理

　　　　在 MySQL 里面：

　　　　　　1 个 DBMS（数据库管理系统）可以有很多 DB（数据库）

　　　　　　1 个 DB 里面可以有很多 table（表）

　　　　　　1 个 table 里面可以有很多条 data（数据）

　　　　在 MongoDB 里面：

　　　　　　1个 DBMS 可以有很多 DB

　　　　　　1个 DB 里面可以有很多 collection（集合）

　　　　　　1个 collection 里面可以有很多条 document（文档）

　　　　　　

 

•  文档（document）的增删改查

　　　　新增数据：进入到某一个集合页面，点击 ADD DATA，可以选择直接导入 josn 文件，也可以手动写入 json 数据

　　　　新增数据时，id不是必须的，但必须保证 id 的唯一性，如果有重复的 id 会报错

　　　　

　　　　查找数据：documents 下面的 options 选项可以选择查找数据的条件，以及数据的正序倒序

　　　　

　　　　修改数据，删除数据，可以在数据上直接操作

　　　　

 　　　　导出数据，可以选择导出符合条件的数据，也可以选择导出全部数据，导出的数据为 json 格式

　　　　

 

•  BSON

　　　　JSON 是字符串类型的，但 MongoDB 存储数据到硬盘，需要存储二进制数据

　　　　BSON = Binary JSON 即二进制类型的 JSON

　　　　

• nosql

　　　　sql，关系型数据库，如 mysql，oracle，sql server

　　　　nosql，非关系数据库（not only sql），如 MongoDB，Redis

 　　　　关系型数据库需要另外学习 sql 语言，如 select，insert，uodate，delete等

　　　　非关系型数据库无需用 sql 语句查询，易学易用

 

• nodejs 连接 MongoDB（实现数据的增删查改）

// 连接Mongodb数据库, 使用Mongodb的驱动程序
// 1. 引入mongodb模块
const MongoClient = require("mongodb").MongoClient;
// 2. 定义连接地址
const url = "mongodb://127.0.0.1:27017";
// 3. 定义数据库名称
const dbName = "myDB";
// 4. 连接数据库
MongoClient.connect(
    url,
    {
        useUnifiedTopology: true,
        useNewUrlParser: true,
    },
    (error, client) => {
        if (error) {
            console.log(error);
            return;
        }
        console.log("连接成功");
        // 选择数据库
        const db = client.db(dbName);
        //选择合集
        const userCollection = db.collection("users");
        //查询所有数据
        userCollection.find().toArray((err, result) => {
            if(err){
                console.log(err);
                return;
            }
            console.log(result);
        })
        //查询结果按倒序排序
        userCollection.find().sort({age: -1}).toArray((err, result) => {
            if(err){
                console.log(err);
                return;
            }
            console.log(result);
        })
        //条件查询
        userCollection.find({username: "zhangsan-1"}).sort().toArray((err, result) => {
            if(err){
                console.log(err);
                return;
            }
            console.log(result);
        })
        //新增数据,返回插入几条数据，插入数据的id
        userCollection.insertOne({
            username: "lisi",
            age: 44,
            password: "123456-lisi",
            email: "lisi@qq.com",
            gender: "unknown",
        },
        (err, result) => {
            if(err){
                console.log(err);
                return;
            }
            console.log(result.insertedCount, result.insertedId);
        })
        //修改数据
        userCollection.updateMany(
            { username: "lisi"},
            { $set: { age: 77, gender: "female"},},
            (error, result) => {
                if(error){
                    console.log(error);
                    return;
                }
                //打印结果，modifiedCount表示修改的数据条数
                console.log(result.modifiedCount);
            })
        //删除数据，需要先写查询条件，符合条件的数据会被删去，会返回 deleteCount，删除的条数
        userCollection.deleteOne({
            username: "zhangsan-1"
        },
        (error,result) => {
            if(error){
                console.log(error);
                return;
            }
            console.log(result.deleteCount);
        })
        client.close(db);
    }
);

 

 

• mongoose

　　　　mongoDB 的数据格式过于灵活，可以插入任何数据，不受限制，实际项目开发时，要有数据格式的规范

　　　　mongooes 可以提供这种规范，用 Schema 定义数据格式的规范，用 Model 规范 collection，还可以规范数据操作的 api

　　　　可以先使用脚手架，搭建 koa2 项目，然后添加 mongooes，命令为 npm i mongoose

　　　　使用 mongoose 连接数据库:

//数据库设置
const mongoose = require("mongoose");
const url = 'mongodb://127.0.0.1:27017';
const dbName = 'module_mongo';

//开始连接
mongoose.connect(`${url}/${dbName}`);
const coon = mongoose.connection;

//监听连接状态
coon.on("error",(err) => console.log(err));
coon.on("open",() => console.log("数据库连接成功！"));

//导出
module.exports = mongoose;

 

• 使用 mongoose 创建数据模型

　　　　所谓数据模型，就是规范数据格式用的，mongoose 可以提供这种规范，用 schema 定义数据格式的规范（类似于表结构），用 Model 规范 collection，还可以规范数据操作的 api

　　　　定义数据模型：

//引入 mongoose
const mongoose = require("mongoose");

//定义 schema
const UserSechema = mongoose.Schema(
    {
        username: {
            type: String, //字符串类型
            required: true, //是否必须写
            unique: true, //是否唯一
        },
        age: {
            type: Number, //数字类型
            default: 0, //可以不传，默认值是0
        },
        password: {
            type: String, //字符串类型
            required: true, // 必传
        },
        email: {
            type: String,
            default: "" //默认为空
        },
        gender: {
            type: String,
            default: "male", //默认为 male
        }
    },
    {
        timestamps: true, // 配置，自动添加时间戳，用来记录数据的创建时间和修改时间
    }
)

// 给 collection 绑定规则
// 定义 model，第一个参数对应 collection 的单数（如 collection 是 users，第一个参数就是 user），第二个参数对应规则
const User = mongoose.model("user", UserSechema);

//导出
module.exports = {
    User,
};

 

 

• 使用 mongoose 进行数据的 增删查改

// 导入 model
const { User } = require("./model")

//立即执行函数 !( function(){} )()
//新增数据
!(async () => {
    const lisi = await User.create({
        username: "lisi-1",
        password: "123456",
        age: 23,
    });
    console.log(lisi);
})();

//查询数据，会返回一个数组，查询到多少都会是一个数组
!(async () => {
    const  userlist = await User.find();
    console.log(userlist);
})()

//条件查询
!(async () => {
    const  userlist = await User.find({ username: "lisi-1"});
    console.log(userlist);
})()

//单条数据查询：findOne，会返回一个对象，如果没查到返回 null
//如果查询到的有多条，返回第一个
!(async () => {
    const  userlist = await User.findOne({ username: "lisi-1"});
    console.log(userlist);
})()

//更新数据：找到第一条符合条件的数据并更新
!(async () => {
    const  updateResult = await User.findOneAndUpdate(
        { username: "lisi-1"},//查询条件
        { age: 44},//更新的内容
        { new: true}//返回更新后的数据
        );
    console.log(updateResult);
})()

//删除数据，找到第一条符合条件的数据并删除
!(async () => {
    const  deleteResult = await User.deleteOne(
        { gender: "female"},//查询条件
        );
    //deletedCount:删除的数据条数
    console.log(deleteResult.deletedCount);
})()

 

• 完善留言板路由功能（post请求）

　　首先连接数据库

//引入 mongoose
const mongoose = require('mongoose')
const url = 'mongodb://127.0.0.1:27017'
const dbName = 'myDB'

//连接
mongoose.connect(`${url}/${dbName}`);
const coon = mongoose.connection;

coon.on('error',(err) => {
    console.log(err);
})
coon.on('open',() => {
    console.log("数据库连接成功");
})

//导出
module.exports = mongoose;

 

　　然后设置数据格式

 //定义数据结构

//引入 mongoose
const mongoose = require('./index')


const commentSchema = mongoose.Schema(
    {
        username: {
            type: String,
            required: true,
        },
        content: {
         type: String,
            required: true,
        }
    },
    {
        timestamps: true,
    }
);




//定义 model
const comment = mongoose.model('comments',commentSchema)
//导出
module.exports = {
    comment,
}

 　　最后新建路由，设置方法

const router = require('koa-router')()
//导入 model
const { comment } = require('../db/model')

//设置前缀
router.prefix('/comment')

//设置路由，获取评论列表
router.get('/list', async (ctx, next) => {
    // 获取 queryString
    const query = ctx.query;
    // 用户想查询多少条，默认五条
    const queryNumber = query.number || 5;
    //查询数据库
    const commentList = await comment.find().sort({ createdAt: -1}).limit(queryNumber);
    //返回 json 
    ctx.body = {
        errno: 0,
        message:`获取留言列表成功！共有${commentList.length}条留言`,
        data:commentList
    };
});

//设置路由，新增评论
router.post('/create', async (ctx, next) => {
    //获取请求体
    const body = ctx.request.body;
    const { content, username } = body;
    //把数据添加到数据库
    const newContent = await comment.create({
        content,
        username,
    });
    //设置响应体
    ctx.body = {
        errno: 0,
        message: "留言成功",
        data: newContent,
    }
})

//导出路由
module.exports = router

　　别忘了注册路由，在 app.js 中