1.概念

mongodb

mongodb是文档型数据库
简单理解就是 把json对象直接保存和读取的数据库
Redis，MongoDB都是常见的NoSQL数据库

mongoose：

1.定义

mongodb直接保存json对象，无法体现数据表结构的定义，不便于人们统一维护 通过模仿关系型数据库的来定义非关系型数据库，所以mongoose 诞生了

2.数据库设计与接口的流程

1. 传统
   • 原型 -> ER -> DB -> 后端代码 -> api -> UI开发
2. 使用Sequlize java orm
   • 原型 -> 后端代码(领域模型) -> api -> adminUI

2.服务端配置

#下载mongodb包 mongodb-linux-x86_64-3.0.6.tgz
#解压tgz
tar -zxvf mongodb-linux-x86_64-3.0.6.tgz
#剪切到 /usr/local/mongodb 
mv -r mongodb-linux-x86_64-3.0.6 /usr/local/mongodb
#编辑 环境变量
sudo vi /etc/profile
#加入mongoDB配置
export MONGODB_HOME=/usr/local/mongodb
export PATH=$PATH:$MONGODB_HOME/bin
#刷新配置
source /etc/profile

#建立关联文件
#整体创建思路 /usr/local/mongodb/ 下
#创建 data/db 和 logs/mongodb.log 和 bin/mongod.conf

#1.创建 data/db 和 logs/mongodb.log
 cd /usr/local/mongodb
 sudo mkdir -p data/db
 #给予最高权限
 sudo chmod -R 777 data/db
 sudo mkdir logs 
 cd logs
 touch mongodb.log 

#2.创建 bin/mongod.conf
#进度安装路径 
cd /usr/local/mongodb/bin
#创建配置信息
touch mongodb.conf 
#mongodb.conf的内容如下
bind_ip = 0.0.0.0 #开通外网访问
dbpath = /usr/local/mongodb/data/db #数据文件存放目录  
logpath = /usr/local/mongodb/logs/mongodb.log #日志文件存放目录  
port = 27017  #端口  
fork = true  #以守护程序的方式启用，即在后台运行  
auth = true
nohttpinterface = true  

3.常用命令

# 启动 关闭
cd /usr/local/mongodb/bin
#启动
./mongod -f mongodb.conf
#关闭
./mongod --shutdown --dbpath=../data/db

#查看当前进程
ps -ef|grep mongo
#查看mongod.conf 位置
find / -name "*mongod.conf*" -type d

# 账户登陆+ 操作
cd /usr/local/mongodb/bin
#账户登陆
./mongo -u admin -p xxxx 
#创建用户
db.createUser({user: "admin",pwd: ,"xxxx",roles: [ {role: "root",db: "admin"} ]})
#xxxx为密码

#显示所有用户
show users

#显示所有数据库
show dbs
# 切换数据库
use admin
use mytestDb 

#导出
mongoexport -p 27017  -u mongoadmin -p mongoadmin --authenticationDatabase admin -d dbname -c collectionName -o ./fileName.json
#导入
mongoimport -p 27017  -u mongoadmin -p mongoadmin --authenticationDatabase admin -d dbname -c collectionName --file ./fileName.json

4.实战

4.1.mongoDB + node 直接操作

4.1.1.连接与基本操作

//安装
 npm install mongodb --save
 //连接与操作
(async () => {
  const { MongoClient: MongoDB } = require('mongodb')

  // 创建客户端
  const client = new MongoDB(
    'mongodb://localhost:27017',
    {
      userNewUrlParser: true
    }
  )
  let ret
  // 创建连接
  ret = await client.connect()
  console.log('ret:', ret)
  const db = client.db('test')
  const fruits = db.collection('fruits')

  // 添加文档
  ret = await fruits.insertOne({
    name: '芒果',
    price: 20.1
  })
  console.log('插入成功', JSON.stringify(ret))

  // 查询文档
  ret = await fruits.findOne()
  console.log('查询文档:', ret)

  // 更新文档
  ret = await fruits.updateOne({ name: '芒果' }, 
  { $set: { name: '苹果' } })
  console.log('更新文档', JSON.stringify(ret.result))

  // 删除文档
  ret = await fruits.deleteOne({name: '苹果'})

  await fruits.deleteMany()

  client.close()

})()

4.1.2.通过events订阅 连接成功发布

//conf.js
module.exports = {
    url: "mongodb://localhost:27017",
    dbName: 'test',
}
//db.js
const conf = require("./conf");
const EventEmitter = require("events").EventEmitter;

// 客户端
const MongoClient = require("mongodb").MongoClient;

class Mongodb {
  constructor(conf) {
    // 保存conf
    this.conf=conf;

    this.emmiter = new EventEmitter();
    // 连接
    this.client = new MongoClient(conf.url, { useNewUrlParser: true });
    this.client.connect(err => {
      if (err) throw err;
      console.log("连接成功");
      this.emmiter.emit("connect");
    });
  }
  col(colName, dbName = conf.dbName) {
    return this.client.db(dbName).collection(colName);
  }
  once(event, cb) {
    this.emmiter.once(event, cb);
  }
}
// 2.导出db
module.exports = new Mongodb(conf);

//testdata.js
const mongodb = require("./db");
mongodb.once("connect", async () => {
  const col = mongodb.col("fruits");
  try {
    // 删除已存在
    await col.deleteMany();
    // 插入
    await col.insertMany([
      { name: "苹果", price: 5, category: "水果" },
      { name: "香蕉", price: 3.5, category: "水果" },
      { name: "芒果", price: 15, category: "水果" },
      { name: "砂糖橘", price: 8, category: "水果" },
      { name: "土豆", price: 2, category: "蔬菜" },
      { name: "西红柿", price: 3, category: "蔬菜" },
      { name: "茄子", price: 4, category: "蔬菜" },
      { name: "韭菜", price: 5, category: "蔬菜" },
      { name: "牛肉", price: 30, category: "生鲜" },
      { name: "鱼", price: 12, category: "生鲜" },
      { name: "大闸蟹", price: 99, category: "生鲜" },
      { name: "鲜虾", price: 20, category: "生鲜" }
    ]);
    console.log("插入测试数据成功");
    const ret = await col.find({price:{$gt:10}}).toArray()
    console.log('ret',ret)
  } catch (error) {
    console.log("插入测试数据失败");
    console.log(error);
  }
});

4.1.3.分页代码

const fruits = await col
    .find()
    .skip((page - 1) * 5)
    .limit(5)
    .toArray()

4.2.mongoose + node

4.2.1.连接数据库方式

//直接连接数据库方式
const mongoose = require('mongoose')
const {
    Schema
} = mongoose
mongoose.connect('mongodb://username:pwd@81.71.143.xxx:27017/weixin?authSource=admin', {
    useNewUrlParser: true
}, () => {
    console.log('Mongodb connected..')
})
exports.ServerToken = mongoose.model('ServerToken', {
    accessToken: String
});

//使用
 async () => await ServerToken.findOne()

4.2.2.连接与使用

//安装
npm i mongoose -S
// mongoose.js
const mongoose = require("mongoose");

// 1.连接
mongoose.connect("mongodb://localhost:27017/test",
    { useNewUrlParser: true }
);

const conn = mongoose.connection;
conn.on("error", () => console.error("连接数据库失败"));
conn.once("open", async () => {

    // 2.定义一个Schema - Table
    const Schema = mongoose.Schema({
        category: String,
        name: String
    });

    // 3.编译一个Model, 它对应数据库中复数、小写的Collection
    const Model = mongoose.model("new", Schema);
    try {
        // 4.创建，create返回Promise
        let r = await Model.create({
            category: "温带水果",
            name: "苹果",
            price: 5
        });
        console.log("插入数据:", r);

        // 5.查询，find返回Query，它实现了then和catch，可以当Promise使用
        // 如果需要返回Promise，调用其exec()
        r = await Model.find({ name: "苹果" });
        console.log("查询结果:", r);

        // 6.更新，updateOne返回Query
        r = await Model.updateOne({ name: "苹果" }, { $set: { name: '芒果' } });
        console.log("更新结果：", r);

        // 7.删除，deleteOne返回Query
        r = await Model.deleteOne({ name: "苹果" });
        console.log("删除结果：", r);
    } catch (error) {
        console.log(error);
    }
});