MongoDB快速入门

最新推荐文章于 2024-05-12 23:45:22 发布

Heri.MG

最新推荐文章于 2024-05-12 23:45:22 发布

阅读量805

点赞数

分类专栏： mongoDB 文章标签： java

本文链接：https://blog.csdn.net/weixin_44532692/article/details/105798418

版权

mongoDB 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

MongoDB简介

官网：https://www.mongodb.com/

什么是MongoDB ?

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。

在高负载的情况下，添加更多的节点，可以保证服务器性能。

MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

整体架构：

主要特点

MongoDB 是一个面向文档存储的数据库，操作起来比较简单和容易。
你可以在MongoDB记录中设置任何属性的索引 (如：FirstName=“Sameer”,Address=“8 Gandhi Road”)来实现更快的排序。
你可以通过本地或者网络创建数据镜像，这使得MongoDB有更强的扩展性。
如果负载的增加（需要更多的存储空间和更强的处理能力），它可以分布在计算机网络中的其他节点上这就是所谓的分片。
Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。
MongoDb 使用update()命令可以实现替换完成的文档（数据）或者一些指定的数据字段。
Mongodb中的Map/reduce主要是用来对数据进行批量处理和聚合操作。
Map和Reduce。Map函数调用emit(key,value)遍历集合中所有的记录，将key与value传给Reduce函数进行处理。
Map函数和Reduce函数是使用Javascript编写的，并可以通过db.runCommand或mapreduce命令来执行MapReduce操作。
GridFS是MongoDB中的一个内置功能，可以用于存放大量小文件。
MongoDB允许在服务端执行脚本，可以用Javascript编写某个函数，直接在服务端执行，也可以把函数的定义存储在服务端，下次直接调用即可。
MongoDB支持各种编程语言:RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。
MongoDB安装简单。

缺点

对事物的支持不太好
在集群分片中的数据分布不均匀
单机可靠性比较差
大数据量持续插入，写入性能有较大波动
磁盘空间占用比较大

使用场景

游戏场景，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、更新
物流场景，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。
社交场景，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能
物联网场景，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析
视频直播，使用 MongoDB 存储用户信息、礼物信息等
……

SQL术语/概念

SQL术语/概念	MongoDB术语/概念	解释/说明
database	database	数据库
table	collection	数据库表/集合
row	document	数据记录行/文档
column	field	数据字段/域
index	index	索引
table joins		表连接,MongoDB不支持
primary key	primary key	主键,MongoDB自动将_id字段设置为主键

下载安装

下载

下载地址：https://www.mongodb.com/download-center#community

如果官网下载速度慢，可以直接在我

百度网盘上下载

链接：https://pan.baidu.com/s/1xIY0dWZ-zNM8w8pGQu5-2g
提取码：u8ov

windows安装

https://www.runoob.com/mongodb/mongodb-window-install.html

linux安装

将下载好的压缩包上传到服务器或linux系统中，解压

tar -xvf mongodb-linux-x86_64-4.0.10.tgz

新建几个目录，分别用来存储数据和日志、配置

mkdir -p /usr/local/mongodb/data
mkdir -p /usr/local/mongodb/log
mkdir -p /usr/local/mongodb/conf

新建并修改配置文件

vim /usr/local/mongodb/conf/mongod.conf

内容如下：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/usr/local/mongodb/log/mongod.log"
  logAppend: true
storage:
  #mongod实例存储其数据的目录
  dbPath: "/usr/local/mongodb/data"
  journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
    enabled: true
processManagement: 
   #启用在后台运行mongos或mongod进程的守护进程模式。 
   fork: true
net:
   #服务实例绑定的IP，默认是localhost 
   bindIp: 0.0.0.0
   port: 27017

启动

MongoDB服务，进入MongoDB的bin目录执行命令

./mongod - f /usr/local/mongodb/conf/mongod.conf

关闭服务

通过mongo客户端中的shutdownServer命令来关闭服务

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行。 
mongo --port 27017 
//#切换到admin库 
use admin 
//关闭服务 
db.shutdownServer()

数据修复

果一旦是因为数据损坏，则需要进行如下操作

删除lock文件

rm -f  /usr/local/mongodb/data/*.lock

修复数据

/usr/local/mongdb/bin/mongod --repair --dbpath=/usr/local/mongodb/data

连接MongoDB

使用shell命令连接

在bin目录下执行

mongo --port 27017 --host=127.0.0.1

使用可视化工具连接

可视化工具有很多，我使用的是官方提供的工具

下载地址：https://www.mongodb.com/download-center/compass

我百度网盘也有安装包

链接：https://pan.baidu.com/s/1xIY0dWZ-zNM8w8pGQu5-2g
提取码：u8ov

成功之后的样子

MongoDB命令

数据库

先看看自带就有的三个数据库

admin：从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合
config: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

创建，切换数据库

数据库存在则是切换，反之创建数据库

use 数据库名

查看数据库

查看有权限查看的所有的数据库命令（注：刚刚创建的数据库里面没有数据是不能通过这个命令来查看的，因为MongoDB的数据库存储机制，是先把空的库存在内存中，当有数据、集合了就会自动进行持久化）

show dbs

查看正在使用的的数据库

db

删除数据库

db.dropDatabase()

集合

MongoDB的集合和我的mysql中的表一个意思

显式创建（一般不用）

命令：

db.createCollection(name, options)

参数说明：

name: 要创建的集合名称
options: 可选参数, 指定有关内存大小及索引的选项

options 可以是如下参数：

字段	类型	描述
capped	布尔	（可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。
autoIndexId	布尔	（可选）如为 true，自动在 _id 字段创建索引。默认为 false。
size	数值	（可选）为固定集合指定一个最大值，以千字节计（KB）。如果 capped 为 true，也需要指定该字段。
max	数值	（可选）指定固定集合中包含文档的最大数量。

隐式创建

也就是在文档插入的时候，会自动创建

查看集合

show collections 
或
show tables

删除集合

db.collection.drop()

集合的命名规范：

集合名不能是空字符串""。
集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
集合名不能以"system."开头，这是为系统集合保留的前缀。
用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。

文档

文档的数据结构和 JSON 基本一样。

所有存储在集合中的数据都是 BSON 格式。

BSON 是一种类似 JSON 的二进制形式的存储格式，是 Binary JSON 的简称。

文档插入

单条插入

db.collection.insert( 
    <document or array of documents>, 
    { 
    	writeConcern: <document>, 
    	ordered: <boolean> 
    }
)

【示例】

db.comment.insert({
    "articleid": "100000",
    "content": "今天天气真好，阳光明 媚",
    "userid": "1001",
    "nickname": "Rose",
    "createdatetime": new Date(),
    "likenum": NumberInt(10),
    "state": null
})

执行后，如下图，表成功：

提示：

comment集合如果不存在，则会隐式创建
mongo中的数字，默认double类型，如要存整型，必须使用函数NumberInt，否则取出来就有问题了。
插入当前日期使用 new Date()
插入的数据没有指定 _id ，会自动生成主键值
如果某字段没值，可以赋值为null，或不写该字段。

文档键命名规范：

键不能含有\0 (空字符)。这个字符用来表示键的结尾。
.和$有特别的意义，只有在特定环境下才能使用。
以下划线"_"开头的键是保留的(不是严格要求的)

批量插入

语法：

db.collection.insertMany(
    [ <document 1> , <document 2>, ... ], 
    { writeConcern: <document>, ordered: <boolean> }
)

【示例】

批量插入多条文章评论：

db.comment.insertMany([{
    "_id": "1",
    "articleid": "100001",
    "content": "我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我 他。",
    "userid": "1002",
    "nickname": "相忘于江湖",
    "createdatetime": new Date("2019-08- 05T22:08:15.522Z"),
    "likenum": NumberInt(1000),
    "state": "1"
},
{
    "_id": "2",
    "articleid": "100001",
    "content": "我夏天空腹喝凉开水，冬天喝温开水",
    "userid": "1005",
    "nickname": "伊人憔 悴",
    "createdatetime": new Date("2019-08-05T23:58:51.485Z"),
    "likenum": NumberInt(888),
    "state": "1"
},
{
    "_id": "3",
    "articleid": "100001",
    "content": "我一直喝凉开水，冬天夏天都喝。",
    "userid": "1004",
    "nickname": "杰克船 长",
    "createdatetime": new Date("2019-08-06T01:05:06.321Z"),
    "likenum": NumberInt(666),
    "state": "1"
},
{
    "_id": "4",
    "articleid": "100001",
    "content": "专家说不能空腹吃饭，影响健康。",
    "userid": "1003",
    "nickname": "凯 撒",
    "createdatetime": new Date("2019-08-06T08:18:35.288Z"),
    "likenum": NumberInt(2000),
    "state": "1"
},
{
    "_id": "5",
    "articleid": "100001",
    "content": "研究表明，刚烧开的水千万不能喝，因为烫 嘴。",
    "userid": "1003",
    "nickname": "凯撒",
    "createdatetime": new Date("2019-08- 06T11:01:02.521Z"),
    "likenum": NumberInt(3000),
    "state": "1"
}]);

之前说了，Mongodb 不支持事务所以批量插入的时候我要是其中一条数据出错了，我们就不知道那一条数据出错了，所以可以通过try catch 来打印错误命令如下：

try {  
    db.comment.insertMany([{
    "_id": "1",
    "articleid": "100001",
    "content": "我们不应该把清晨浪费在手机上，健康很重要",
    "userid": "1002",
    "nickname": "相忘于江湖",
    "createdatetime": new Date("2019-08- 05T22:08:15.522Z"),
    "likenum": NumberInt(1000),
    "state": "1"
    },
    {
        "_id": "2",
        "articleid": "100001",
        "content": "我夏天空腹喝凉开水，冬天喝温开水",
        "userid": "1005",
        "nickname": "伊人憔 悴",
        "createdatetime": new Date("2019-08-05T23:58:51.485Z"),
        "likenum": NumberInt(888),
        "state": "1"
    },
    {
        "_id": "3",
        "articleid": "100001",
        "content": "我一直喝凉开水，冬天夏天都喝。",
        "userid": "1004",
        "nickname": "杰克船 长",
        "createdatetime": new Date("2019-08-06T01:05:06.321Z"),
        "likenum": NumberInt(666),
        "state": "1"
    },
    {
        "_id": "4",
        "articleid": "100001",
        "content": "专家说不能空腹吃饭，影响健康。",
        "userid": "1003",
        "nickname": "凯 撒",
        "createdatetime": new Date("2019-08-06T08:18:35.288Z"),
        "likenum": NumberInt(2000),
        "state": "1"
    },
    {
        "_id": "5",
        "articleid": "100001",
        "content": "研究表明，刚烧开的水千万不能喝，因为烫 嘴。",
        "userid": "1003",
        "nickname": "凯撒",
        "createdatetime": new Date("2019-08- 06T11:01:02.521Z"),
        "likenum": NumberInt(3000),
        "state": "1"
    }]);
} catch (e) { 
    print (e); 
}

查询文档

查询全部

db.collenction.find(<query>, [projection]);

参数：

Parameter	Type	Description
query	document	可选。使用查询运算符指定选择筛选器。若要返回集合中的所有文档，请省略此参数或传递空文档 ({})
projection	document	可选。指定要在与查询筛选器匹配的文档中返回的字段（投影）。若要返回匹配文档中的所有字段，

【示例】

这里你会发现每条文档会有一个叫_id的字段，这个相当于我们原来关系数据库中表的主键，当你在插入文档记录时没有指定该字段， MongoDB会自动创建，其类型是ObjectID类型。如果我们在插入文档记录时指定该字段也可以，其类型可以是ObjectID类型，也可以是MongoDB支持的任意类型.

按条件查询

db.comment.find({userid:'1001'})

当然有时候一个类型或者一个部门啥的，我们只想查这个类型的第一天数据可以用findone这个命令

如：我要查询用户编号1001的记录

db.comment.findOne({userid:'1001'})

投影查询（Projection Query）

如果要查询结果返回部分字段，则需要使用投影查询（不显示所有字段，只显示指定的字段）。

如：查询结果只显示 _id、userid、nickname :

db.comment.find({userid:"1003"},{userid:1,nickname:1})

如：查询结果只显示、userid、nickname ，不显示 _id ：

db.comment.find({userid:"1003"},{userid:1,nickname:1,_id:0})

再例如：查询所有数据，但只显示 _id、userid、nickname :

db.comment.find({},{userid:1,nickname:1})

统计查询

【语法】

db.collection.count(query, options)

参数：

Parameter	Type	Description
query	document	查询选择条件。
options	document	可选。用于修改计数的额外选项。

【示例】

统计comment集合的所有的记录数：

db.comment.count()

统计userid为1003的记录条数

db.comment.count({userid:"1003"})

修改文档

更新文档的语法：

db.collection.update(query, update, options) 
或 
db.collection.update( 
    <query>, 
    <update>, 
    { 
        upsert: <boolean>, 
        multi: <boolean>, 
        writeConcern: <document>, 
        collation: <document>, 
        arrayFilters: [ <filterdocument1>, ... ], 
        hint: <document|string> // Available starting in MongoDB 4.2 
    }
)

【示例】

覆盖的修改

如果我们想修改_id为1的记录，点赞量为1001，输入以下语句：

db.comment.update({_id:"1"},{likenum:NumberInt(1001)})

执行后，我们会发现，这条文档除了likenum字段其它字段都不见了

局部修改

为了解决这个问题，我们需要使用修改器$set来实现，命令如下：

我们想修改_id为2的记录，浏览量为889，输入以下语句：

db.comment.update({_id:"2"},{$set:{likenum:NumberInt(889)}})

批量修改

更新所有用户为 1003 的用户的昵称为凯撒大帝。

//默认只修改第一条数据 
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒2"}}) 
//修改所有符合条件的数据 
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒大帝"}},{multi:true})

提示：如果不加后面的参数，则只更新符合条件的第一条记录

列值增长的修改

如果我们想实现对某列值在原有值的基础上进行增加或减少，可以使用 $inc 运算符来实现。

需求：对3号数据的点赞数，每次递增1

db.comment.update({_id:"3"},{$inc:{likenum:NumberInt(1)}})

删除文档

删除文档的语法结构：

db.集合名称.remove(条件)

以下语句可以将数据全部删除，请慎用

db.comment.remove({})

如果删除_id=1的记录，输入以下语句

db.comment.remove({_id:"1"})

复杂查询

统计查询

db.collection.count(query, options)

参数：

Parameter	Type	Description
query	document	查询选择条件。
options	document	可选。用于修改计数的额外选项。

【示例】

统计comment集合的所有的记录数：

db.comment.count()

统计userid为1003的记录条数

db.comment.count({userid:"1003"})

分页查询

可以使用limit()方法来读取指定数量的数据，使用skip()方法来跳过指定数量的数据

基本语法如下所示：

db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

如果你想返回指定条数的记录，可以在fifind方法后调用limit来返回结果(TopN)，默认值20，例如

db.comment.find().limit(3)

skip方法同样接受一个数字参数作为跳过的记录条数。（前N个不要）,默认值是0

db.comment.find().skip(3)

分页查询：需求：每页2个，第二页开始：跳过前两条数据，接着值显示3和4条数据

//第一页 
db.comment.find().skip(0).limit(2) 
//第二页 
db.comment.find().skip(2).limit(2) 
//第三页 
db.comment.find().skip(4).limit(2)

排序查询

sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列

db.COLLECTION_NAME.find().sort({KEY:1}) 
或
db.集合名称.find().sort(排序方式)

例如：

对userid降序排列，并对访问量进行升序排列

db.comment.find().sort({userid:-1,likenum:1})

提示：

skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()，和命令编写顺序无关。

正则查询

MongoDB的模糊查询是通过正则表达式的方式实现的。格式为：

db.collection.find({field:/正则表达式/})
或
db.集合.find({字段:/正则表达式/})

提示：正则表达式是js的语法，直接量的写法。

例如，我要查询评论内容包含“开水”的所有文档，代码如下：

db.comment.find({content:/开水/})

如果要查询评论的内容中以“专家”开头的，代码如下：

db.comment.find({content:/^专家/})

比较查询

<, <=, >, >= 这个操作符也是很常用的，格式如下:

db.集合名称.find({ "field" : { $gt: value }}) // 大于: field > value 
db.集合名称.find({ "field" : { $lt: value }}) // 小于: field < value 
db.集合名称.find({ "field" : { $gte: value }}) // 大于等于: field >= value 
db.集合名称.find({ "field" : { $lte: value }}) // 小于等于: field <= value 
db.集合名称.find({ "field" : { $ne: value }}) // 不等于: field != value

示例：查询评论点赞数量大于700的记录

db.comment.find({likenum:{$gt:NumberInt(700)}})

包含查询

包含使用$in操作符。示例：查询评论的集合中userid字段包含1003或1004的文档

db.comment.find({userid:{$in:["1003","1004"]}})

不包含使用$nin操作符。示例：查询评论集合中userid字段不包含1003和1004的文档

db.comment.find({userid:{$nin:["1003","1004"]}})

条件连接查询

我们如果需要查询同时满足两个以上条件，需要使用$and操作符将条件进行关联。格式为：

$and:[ { },{ },{ } ]

示例：查询评论集合中likenum大于等于700 并且小于2000的文档：

db.comment.find({$and:[{likenum:{$gte:NumberInt(700)}},{likenum:{$lt:NumberInt(2000)}}]})

如果两个以上条件之间是或者的关系，我们使用操作符进行关联，与前面 and的使用方式相同格式为：

$or:[ { },{ },{ } ]

示例：查询评论集合中userid为1003，或者点赞数小于1000的文档记录

db.comment.find({$or:[ {userid:"1003"} ,{likenum:{$lt:1000} }]})

常用命令总结

索引

索引支持在MongoDB中高效地执行查询。如果没有索引，MongoDB必须执行全集合扫描，即扫描集合中的每个文档，以选择与查询语句

匹配的文档。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非

常致命的。

如果查询存在适当的索引，MongoDB可以使用该索引限制必须检查的文档数。

索引是特殊的数据结构，它以易于遍历的形式存储集合数据集的一小部分。索引存储特定字段或一组字段的值，按字段值排序。索引项的排

序支持有效的相等匹配和基于范围的查询操作。此外，MongoDB还可以使用索引中的排序返回排序结果。

官网文档：https://docs.mongodb.com/manual/indexes/

MongoDB索引使用B树数据结构（确切的说是B-Tree，MySQL是B+Tree）

索引的类型

单字段索引

MongoDB支持在文档的单个字段上创建用户定义的升序/降序索引，称为单字段索引（Single Field Index）。

对于单个字段索引和排序操作，索引键的排序顺序（即升序或降序）并不重要，因为MongoDB可以在任何方向上遍历索引。

复合索引

MongoDB还支持多个字段的用户定义索引，即复合索引（Compound Index）。

复合索引中列出的字段顺序具有重要意义。例如，如果复合索引由 { userid: 1, score: -1 } 组成，则索引首先按userid正序排序，然后

在每个userid的值内，再在按score倒序排序

其他索引

地理空间索引（Geospatial Index）、文本索引（Text Indexes）、哈希索引（Hashed Indexes）。

地理空间索引（Geospatial Index）

为了支持对地理空间坐标数据的有效查询，MongoDB提供了两种特殊的索引：返回结果时使用平面几何的二维索引和返回结果时使用球面几何的二维球面索引。

文本索引（Text Indexes）

MongoDB提供了一种文本索引类型，支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的停止词（例如“the”、“a”、“or”），而将集合中的词作为词干，只存储根词。

哈希索引（Hashed Indexes）

为了支持基于散列的分片，MongoDB提供了散列索引类型，它对字段值的散列进行索引。这些索引在其范围内的值分布更加随机，但只支持相等匹配，不支持基于范围的查询。

索引的操作

创建索引

db.集合名.createIndex({...}）

参数表

Parameter	Type	Description
background	Boolean	建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加 “background” 可选参数。 “background” 默认值为false。
unique	Boolean	建立的索引是否唯一。指定为true创建唯一索引。默认值为false.
name	string	索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。
dropDups	Boolean	3.0+版本已废弃。在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false.
sparse	Boolean	对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false.
expireAfterSeconds	integer	指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
v	index version	索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。
weights	document	索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。
default_language	string	对于文本索引，该参数决定了停用词及词干和词器的规则的列表。默认为英语
language_override	string	对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language.

【实例】

单字段索引示例：对 userid 字段建立索引：

db.comment.createIndex({userid:1}) 
返回结果
{ 
	"createdCollectionAutomatically" : false, 
	"numIndexesBefore" : 1, 
	"numIndexesAfter" : 2, 
	"ok" : 1 
}

复合索引：对 userid 和 nickname 同时建立复合（Compound）索引：

db.comment.createIndex({userid:1,nickname:-1}) 
{ 
	"createdCollectionAutomatically" : false, 
	"numIndexesBefore" : 2, 
	"numIndexesAfter" : 3, 
	"ok" : 1 
}

查看集合索引

db.集合名.getIndexes()

查看集合索引大小

db.集合名.totalIndexSize()

删除集合所有索引

db.集合名.dropIndexes()

删除集合指定索引

db.集合名.dropIndex("索引名称")

索引的使用

执行计划

分析查询性能（Analyze Query Performance）通常使用执行计划（解释计划、Explain Plan）来查看查询的情况，如查询耗费的时间、是否基于索引查询等。

那么，通常，我们想知道，建立的索引是否有效，效果如何，都需要通过执行计划查看

db.collection.find(query,options).explain(options)

【示例】

查看根据userid查询数据的情况：

 db.comment.find({userid:"1003"}).explain()

关键点看： “stage” : “COLLSCAN”, 表示全集合扫描

下面对userid建立索引

> db.comment.createIndex({userid:1}) 
{ 
	"createdCollectionAutomatically" : false, 
	"numIndexesBefore" : 1, 
	"numIndexesAfter" : 2, 
	"ok" : 1 
}

再次查看执行计划,关键点看： “stage” : “IXSCAN” ,基于索引的扫描

MongoDB 覆盖索引查询

官方的MongoDB的文档中说明，覆盖查询是以下的查询：

所有的查询字段是索引的一部分
所有的查询返回字段在同一个索引中

由于所有出现在查询中的字段是索引的一部分， MongoDB 无需在整个数据文档中检索匹配查询条件和返回使用相同索引的查询结果。

因为索引存在于RAM中，从索引中获取数据比通过扫描文档读取数据要快得多。

MongoDB集群和安全

副本集-Replica Sets

简介

MongoDB中的副本集（Replica Set）是一组维护相同数据集的mongod服务。副本集可提供冗余和高可用性，是所有生产部署的基础。也可以说，副本集类似于有自动故障恢复功能的主从集群。通俗的讲就是用多台机器进行同一数据的异步同步，从而使多台机器拥有同一数据的多个副本，并且当主库当掉时在不需要用户干预的情况下自动切换其他备份服务器做主库。而且还可以利用副本服务器做只读服务器，实现读写分离，提高负载。

（1）冗余和数据可用性复制提供冗余并提高数据可用性。通过在不同数据库服务器上提供多个数据副本，复制可提供一定级别的容错功能，以防止丢失单个数据库服务器。在某些情况下，复制可以提供增加的读取性能，因为客户端可以将读取操作发送到不同的服务上，在不同数据中心维护数据副本可以增加分布式应用程序的数据位置和可用性。您还可以为专用目的维护其他副本，例如灾难恢复，报告或备份。

（2）MongoDB中的复制副本集是一组维护相同数据集的mongod实例。副本集包含多个数据承载节点和可选的一个仲裁节点。在承载数据的节点中，一个且仅一个成员被视为主节点，而其他节点被视为次要（从）节点。主节点接收所有写操作。副本集只能有一个主要能够确认具有{w：“most”}写入关注的写入; 虽然在某些情况下，另一个mongod实例可能暂时认为自己也是主要的。主要记录其操作日志中的数据集的所有更改，即oplog。

辅助(副本)节点复制主节点的oplog并将操作应用于其数据集，以使辅助节点的数据集反映主节点的数据集。如果主要人员不在，则符合条件的中学将举行选举以选出新的主要人员。

（3）主从复制和副本集区别主从集群和副本集最大的区别就是副本集没有固定的“主节点”；整个集群会选出一个“主节点”，当其挂掉后，又在剩下的从节点中选中其他节点为“主节点”，副本集总有一个活跃点(主、primary)和一个或多个备份节点(从、secondary)。

副本集的三个角色

副本集有两种类型三种角色两种类型：

主节点（Primary）类型：数据操作的主要连接点，可读写。

次要（辅助、从）节点（Secondaries）类型：数据冗余备份节点，可以读或选举。

三种角色：

主要成员（Primary）：主要接收所有写操作。就是主节点。

副本成员（Replicate）：从主节点通过复制操作以维护相同的数据集，即备份数据，不可写操作，但可以读操作（但需要配置）。是默认的一种从节点类型。

仲裁者（Arbiter）：不保留任何数据的副本，只具有投票选举作用。当然也可以将仲裁服务器维护为副本集的一部分，即副本成员同时也可以是仲裁者。也是一种从节点类型。

关于仲裁者的额外说明：

您可以将额外的mongod实例添加到副本集作为仲裁者。仲裁者不维护数据集。仲裁者的目的是通过响应其他副本集成员的心跳和选举请求来维护副本集中的仲裁。因为它们不存储数据集，所以仲裁器可以是提供副本集仲裁功能的好方法，其资源成本比具有数据集的全功能副本集成员更便宜。如果您的副本集具有偶数个成员，请添加仲裁者以获得主要选举中的“大多数”投票。仲裁者不需要专用硬件。仲裁者将永远是仲裁者，而主要人员可能会退出并成为次要人员，而次要人员可能成为选举期间的主要人员。如果你的副本+主节点的个数是偶数，建议加一个仲裁者，形成奇数，容易满足大多数的投票。如果你的副本+主节点的个数是奇数，可以不加仲裁者。

副本集架构目标

副本集的创建

第一步：创建主节点

建立存放数据和日志的目录

#-----------myrs
#主节点
mkdir -p /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27017/log \ &
mkdir -p /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27017/data/db

新建配置文件

vim  /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27017/mongod.conf

【内容】

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27017/log/mongod.log"
  logAppend: true
storage:
  #mongod实例存储其数据的目录
  dbPath: "/opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27017/data/db"
  journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
    enabled: true
processManagement: 
   #启用在后台运行mongos或mongod进程的守护进程模式。 
   fork: true
net:
   #服务实例绑定的IP，默认是localhost 
   bindIp: 172.16.53.84,localhost
   port: 27017
   
replication:
#副本集的名称
    replSetName: myrs

启动主节点

./mongod -f /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27017/mongod.conf

第二步：创建副本节点

建立存放数据和日志的目录

#-----------myrs
##副本节点
mkdir -p /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27018/log \ &
mkdir -p /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27018/data/db

新建配置文件

vim  /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27018/mongod.conf

【内容】

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27018/log/mongod.log"
  logAppend: true
storage:
  #mongod实例存储其数据的目录
  dbPath: "/opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27018/data/db"
  journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
    enabled: true
processManagement: 
   #启用在后台运行mongos或mongod进程的守护进程模式。 
   fork: true
net:
   #服务实例绑定的IP，默认是localhost 
   bindIp: 172.16.53.84,localhost
   port: 27018
   
replication:
#副本集的名称
    replSetName: myrs

启动副节点

./mongod -f /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27018/mongod.conf

第三步：创建仲裁节点

建立存放数据和日志的目录

#-----------myrs
##副本节点
mkdir -p /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27019/log \ &
mkdir -p /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27019/data/db

新建配置文件

vim  /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27019/mongod.conf

【内容】

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27019/log/mongod.log"
  logAppend: true
storage:
  #mongod实例存储其数据的目录
  dbPath: "/opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27019/data/db"
  journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
    enabled: true
processManagement: 
   #启用在后台运行mongos或mongod进程的守护进程模式。 
   fork: true
net:
   #服务实例绑定的IP，默认是localhost 
   bindIp: 172.16.53.84,localhost
   port: 27019
   
replication:
#副本集的名称
    replSetName: myrs

启动仲裁节点

./mongod -f /opt/mongodb-linux-x86_64-4.0.18/replica_sets/myrs_27019/mongod.conf

第四步：初始化配置副本集和主节点

使用客户端命令连接任意一个节点，但这里尽量要连接主节点(27017节点)：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yHR3TRem-1587989000109)(http://qn.hzxbk.vip/20200416151826.png)]

结果，连接上之后，很多命令无法使用，，比如 show dbs 等，必须初始化副本集才行

准备初始化新的副本集：

语法：

rs.initiate(configuration)

【选项】

Parameter	Type	Description
configuration	document	Optional. A document that specifies configuration for the new replica set. If a configuration is not specified, MongoDB uses a default replica set configuration.可选的。指定新副本集配置的文档。如果未指定配置，则MongoDB使用默认副本集配置。

【实例】

> rs.initiate()
{
	"info2" : "no configuration specified. Using a default configuration for the set",
	"me" : "172.16.53.84:27017",
	"ok" : 1,
	"operationTime" : Timestamp(1587021611, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587021611, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
myrs:SECONDARY> 
myrs:PRIMARY>

【注】：

1）“ok”的值为1，说明创建成功。

2）命令行提示符发生变化，变成了一个从节点角色，此时默认不能读写。稍等片刻，回车，变成主节点。

第五步：查看副本集的配置内容

【说明】：

返回包含当前副本集配置的文档。

【语法】：

 rs.conf(configuration)

【注】：rs.config() 是该方法的别名。

【示例】

在27017上执行副本集中当前节点的默认节点配置

myrs:PRIMARY> rs.conf()
{
	"_id" : "myrs",
	"version" : 1,
	"protocolVersion" : NumberLong(1),
	"writeConcernMajorityJournalDefault" : true,
	"members" : [
		{
			"_id" : 0,
			"host" : "172.16.53.84:27017",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		}
	],
	"settings" : {
		"chainingAllowed" : true,
		"heartbeatIntervalMillis" : 2000,
		"heartbeatTimeoutSecs" : 10,
		"electionTimeoutMillis" : 10000,
		"catchUpTimeoutMillis" : -1,
		"catchUpTakeoverDelayMillis" : 30000,
		"getLastErrorModes" : {
			
		},
		"getLastErrorDefaults" : {
			"w" : 1,
			"wtimeout" : 0
		},
		"replicaSetId" : ObjectId("5e98072ba69725757421e2ab")
	}
}

【说明】

1） “_id” : “myrs” ：副本集的配置数据存储的主键值，默认就是副本集的名字

2） “members” ：副本集成员数组，此时只有一个： “host” : “172.16.53.84:27017” ，该成员不是仲裁节点： “arbiterOnly” : false ，优先级（权重值）： “priority” : 1,

3） “settings” ：副本集的参数配置。

【提示】

副本集配置的查看命令，本质是查询的是 system.replset 的表中的数据：

myrs:PRIMARY> use local
switched to db local
myrs:PRIMARY> show collections
oplog.rs
replset.election
replset.minvalid
replset.oplogTruncateAfterPoint
startup_log
system.replset
system.rollback.id
myrs:PRIMARY> db.system.replset.find()
{ "_id" : "myrs", "version" : 1, "protocolVersion" : NumberLong(1), "writeConcernMajorityJournalDefault" : true, "members" : [ { "_id" : 0, "host" : "172.16.53.84:27017", "arbiterOnly" : false, "buildIndexes" : true, "hidden" : false, "priority" : 1, "tags" : {  }, "slaveDelay" : NumberLong(0), "votes" : 1 } ], "settings" : { "chainingAllowed" : true, "heartbeatIntervalMillis" : 2000, "heartbeatTimeoutSecs" : 10, "electionTimeoutMillis" : 10000, "catchUpTimeoutMillis" : -1, "catchUpTakeoverDelayMillis" : 30000, "getLastErrorModes" : {  }, "getLastErrorDefaults" : { "w" : 1, "wtimeout" : 0 }, "replicaSetId" : ObjectId("5e98072ba69725757421e2ab") } }
myrs:PRIMARY>

第六步：查看副本集状态

检查副本集状态

【说明】

返回包含状态信息的文档。此输出使用从副本集的其他成员发送的心跳包中获得的数据反映副本集的当前状态。

【语法】

rs.status()

【实例】

在27017上查看副本集状态

myrs:PRIMARY> rs.status()
{
	"set" : "myrs",
	"date" : ISODate("2020-04-16T07:35:58.747Z"),
	"myState" : 1,
	"term" : NumberLong(1),
	"syncingTo" : "",
	"syncSourceHost" : "",
	"syncSourceId" : -1,
	"heartbeatIntervalMillis" : NumberLong(2000),
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" : Timestamp(1587022551, 1),
			"t" : NumberLong(1)
		},
		"readConcernMajorityOpTime" : {
			"ts" : Timestamp(1587022551, 1),
			"t" : NumberLong(1)
		},
		"appliedOpTime" : {
			"ts" : Timestamp(1587022551, 1),
			"t" : NumberLong(1)
		},
		"durableOpTime" : {
			"ts" : Timestamp(1587022551, 1),
			"t" : NumberLong(1)
		}
	},
	"lastStableCheckpointTimestamp" : Timestamp(1587022511, 1),
	"electionCandidateMetrics" : {
		"lastElectionReason" : "electionTimeout",
		"lastElectionDate" : ISODate("2020-04-16T07:20:11.296Z"),
		"electionTerm" : NumberLong(1),
		"lastCommittedOpTimeAtElection" : {
			"ts" : Timestamp(0, 0),
			"t" : NumberLong(-1)
		},
		"lastSeenOpTimeAtElection" : {
			"ts" : Timestamp(1587021611, 1),
			"t" : NumberLong(-1)
		},
		"numVotesNeeded" : 1,
		"priorityAtElection" : 1,
		"electionTimeoutMillis" : NumberLong(10000),
		"newTermStartDate" : ISODate("2020-04-16T07:20:11.298Z"),
		"wMajorityWriteAvailabilityDate" : ISODate("2020-04-16T07:20:11.335Z")
	},
	"members" : [
		{
			"_id" : 0,
			"name" : "172.16.53.84:27017",
			"health" : 1,
			"state" : 1,
			"stateStr" : "PRIMARY",
			"uptime" : 2146,
			"optime" : {
				"ts" : Timestamp(1587022551, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2020-04-16T07:35:51Z"),
			"syncingTo" : "",
			"syncSourceHost" : "",
			"syncSourceId" : -1,
			"infoMessage" : "",
			"electionTime" : Timestamp(1587021611, 2),
			"electionDate" : ISODate("2020-04-16T07:20:11Z"),
			"configVersion" : 1,
			"self" : true,
			"lastHeartbeatMessage" : ""
		}
	],
	"ok" : 1,
	"operationTime" : Timestamp(1587022551, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587022551, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
myrs:PRIMARY>

【说明】

1） “set” : “myrs” ：副本集的名字

2） “myState” : 1：说明状态正常

3） “members” ：副本集成员数组，此时只有一个： “name” : “172.16.53.84:27017” ，该成员的角色是 “stateStr” : “PRIMARY”, 该节点是健康的： “health” : 1 。

第七步：添加副本从节点

在主节点添加从节点，将其他成员加入到副本集

【语法】

rs.add(host, arbiterOnly)

【选项】

Parameter	Type	Description
host	string or document	要添加到副本集的新成员。指定为字符串或配置文档：1）如果是一个字符串，则需要指定新成员的主机名和可选的端口号；2）如果是一个文档，请指定在members数组中找到的副本集成员配置文档。您必须在成员配置文档中指定主机字段。有关文档配置字段的说明，详见下方文档：“主机成员的配置文档”
arbiterOnly	boolean	可选的。仅在值为字符串时适用。如果为true，则添加的主机是仲裁者。

主机成员的配置文档：

{
_id: <int>,
host: <string>, // required
arbiterOnly: <boolean>,
buildIndexes: <boolean>,
hidden: <boolean>,
priority: <number>,
tags: <document>,
slaveDelay: <int>,
votes: <number>
}

【示例】

将27018的副本节点添加到副本集中：

myrs:PRIMARY> rs.add("172.16.53.84:27018")
{
	"ok" : 1,
	"operationTime" : Timestamp(1587023364, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587023364, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

出现 "ok" : 1 说明添加成功了

第八部：添加仲裁节点

【语法】

rs.addArb(host)

【示例】

myrs:PRIMARY> rs.add("172.16.53.84:27019",true)
{
	"ok" : 1,
	"operationTime" : Timestamp(1587023989, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587023989, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
myrs:PRIMARY>

这时候再去查看副本集的状态

就可以看到刚刚添加进去的

myrs:PRIMARY> rs.status()
{
	"set" : "myrs",
	"date" : ISODate("2020-04-16T08:10:27.284Z"),
	"myState" : 1,
	"term" : NumberLong(1),
	"syncingTo" : "",
	"syncSourceHost" : "",
	"syncSourceId" : -1,
	"heartbeatIntervalMillis" : NumberLong(2000),
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" : Timestamp(1587024621, 1),
			"t" : NumberLong(1)
		},
		"readConcernMajorityOpTime" : {
			"ts" : Timestamp(1587024621, 1),
			"t" : NumberLong(1)
		},
		"appliedOpTime" : {
			"ts" : Timestamp(1587024621, 1),
			"t" : NumberLong(1)
		},
		"durableOpTime" : {
			"ts" : Timestamp(1587024621, 1),
			"t" : NumberLong(1)
		}
	},
	"lastStableCheckpointTimestamp" : Timestamp(1587024611, 1),
	"electionCandidateMetrics" : {
		"lastElectionReason" : "electionTimeout",
		"lastElectionDate" : ISODate("2020-04-16T07:20:11.296Z"),
		"electionTerm" : NumberLong(1),
		"lastCommittedOpTimeAtElection" : {
			"ts" : Timestamp(0, 0),
			"t" : NumberLong(-1)
		},
		"lastSeenOpTimeAtElection" : {
			"ts" : Timestamp(1587021611, 1),
			"t" : NumberLong(-1)
		},
		"numVotesNeeded" : 1,
		"priorityAtElection" : 1,
		"electionTimeoutMillis" : NumberLong(10000),
		"newTermStartDate" : ISODate("2020-04-16T07:20:11.298Z"),
		"wMajorityWriteAvailabilityDate" : ISODate("2020-04-16T07:20:11.335Z")
	},
	"members" : [
		{
			"_id" : 0,
			"name" : "172.16.53.84:27017",
			"health" : 1,
			"state" : 1,
			"stateStr" : "PRIMARY",
			"uptime" : 4215,
			"optime" : {
				"ts" : Timestamp(1587024621, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2020-04-16T08:10:21Z"),
			"syncingTo" : "",
			"syncSourceHost" : "",
			"syncSourceId" : -1,
			"infoMessage" : "",
			"electionTime" : Timestamp(1587021611, 2),
			"electionDate" : ISODate("2020-04-16T07:20:11Z"),
			"configVersion" : 3,
			"self" : true,
			"lastHeartbeatMessage" : ""
		},
		{
			"_id" : 1,
			"name" : "172.16.53.84:27018",
			"health" : 1,
			"state" : 2,
			"stateStr" : "SECONDARY",
			"uptime" : 1262,
			"optime" : {
				"ts" : Timestamp(1587024621, 1),
				"t" : NumberLong(1)
			},
			"optimeDurable" : {
				"ts" : Timestamp(1587024621, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2020-04-16T08:10:21Z"),
			"optimeDurableDate" : ISODate("2020-04-16T08:10:21Z"),
			"lastHeartbeat" : ISODate("2020-04-16T08:10:25.329Z"),
			"lastHeartbeatRecv" : ISODate("2020-04-16T08:10:25.429Z"),
			"pingMs" : NumberLong(0),
			"lastHeartbeatMessage" : "",
			"syncingTo" : "172.16.53.84:27017",
			"syncSourceHost" : "172.16.53.84:27017",
			"syncSourceId" : 0,
			"infoMessage" : "",
			"configVersion" : 3
		},
		{
			"_id" : 2,
			"name" : "172.16.53.84:27019",
			"health" : 1,
			"state" : 7,
			"stateStr" : "ARBITER",
			"uptime" : 638,
			"lastHeartbeat" : ISODate("2020-04-16T08:10:25.327Z"),
			"lastHeartbeatRecv" : ISODate("2020-04-16T08:10:25.430Z"),
			"pingMs" : NumberLong(0),
			"lastHeartbeatMessage" : "",
			"syncingTo" : "",
			"syncSourceHost" : "",
			"syncSourceId" : -1,
			"infoMessage" : "",
			"configVersion" : 3
		}
	],
	"ok" : 1,
	"operationTime" : Timestamp(1587024621, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587024621, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
myrs:PRIMARY>

副本集的数据读写操作

目标：测试三个不同角色的节点的数据读写情况。

进入27017节点，写入和读取数据：

use articledb

db.comment.insert({
    "articleid": "100000",
    "content": "今天天气真好，阳光明 媚",
    "userid": "1001",
    "nickname": "Rose",
    "createdatetime": new Date(),
    "likenum": NumberInt(10),
    "state": null
})

登录从节点27018

myrs:SECONDARY> show dbs
2020-04-16T16:20:54.992+0800 E QUERY    [js] Error: listDatabases failed:{
	"operationTime" : Timestamp(1587025251, 1),
	"ok" : 0,
	"errmsg" : "not master and slaveOk=false",
	"code" : 13435,
	"codeName" : "NotMasterNoSlaveOk",
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587025251, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
} :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
Mongo.prototype.getDBs@src/mongo/shell/mongo.js:139:1
shellHelper.show@src/mongo/shell/utils.js:882:13
shellHelper@src/mongo/shell/utils.js:766:15
@(shellhelp2):1:1
myrs:SECONDARY>

发现，不能读取集合的数据。当前从节点只是一个备份，不是奴隶节点，无法读取数据，写当然更不行。因为默认情况下，从节点是没有读写权限的，可以增加读的权限，但需要进行设置。

设置读操作权限：

【说明】：

设置为奴隶节点，允许在从成员上运行读的操作

【语法】：

rs.slaveOk()
#或
rs.slaveOk(true)

【提示】：该命令是 db.getMongo().setSlaveOk() 的简化命令

【示例】

在27018上设置作为奴隶节点权限，具备读权限：

rs:SECONDARY> rs.slaveOk()

运行这个命令没有任何提示

此时，在执行查询命令，运行成功！但仍然不允许插入。

myrs:SECONDARY> rs.slaveOk()
myrs:SECONDARY> show dbs
admin      0.000GB
articledb  0.000GB
config     0.000GB
local      0.000GB
myrs:SECONDARY> use articledb
switched to db articledb
myrs:SECONDARY> db.comment.find()
{ "_id" : ObjectId("5e9814e12a6ec21ef94239ba"), "articleid" : "100000", "content" : "今天天气真好，阳光明 媚", "userid" : "1001", "nickname" : "Rose", "createdatetime" : ISODate("2020-04-16T08:18:41.508Z"), "likenum" : 10, "state" : null }
myrs:SECONDARY>

现在可实现了读写分离，让主插入数据，让从来读取数据。

如果要取消作为奴隶节点的读权限：

rs.slaveOk(false)

仲裁者节点，不存放任何业务数据的，可以登录查看

myrs:ARBITER> rs.slaveOk()
myrs:ARBITER> use local
switched to db local
myrs:ARBITER> show collections
replset.election
replset.minvalid
replset.oplogTruncateAfterPoint
startup_log
system.replset
system.rollback.id
myrs:ARBITER>

主节点的选举原则

MongoDB在副本集中，会自动进行主节点的选举，主节点选举的触发条件：

1）主节点故障

2）主节点网络不可达（默认心跳信息为10秒）

3）人工干预（rs.stepDown(600)）

一旦触发选举，就要根据一定规则来选主节点。

选举规则是根据票数来决定谁获胜：票数最高，且获得了“大多数”成员的投票支持的节点获胜。 “大多数”的定义为：假设复制集内投票成员数量为N，则大多数为 N/2 + 1。例如：3个投票成员，则大多数的值是2。当复制集内存活成员数量不足大多数时，整个复制集将无法选举出Primary，复制集将无法提供写服务，处于只读状态。
若票数相同，且都获得了“大多数”成员的投票支持的，数据新的节点获胜。数据的新旧是通过操作日志oplog来对比的

在获得票数的时候，优先级（priority）参数影响重大。

可以通过设置优先级（priority）来设置额外票数。优先级即权重，取值为0-1000，相当于可额外增加 0-1000的票数，优先级的值越大，就越可能获得多数成员的投票（votes）数。指定较高的值可使成员更有资格成为主要成员，更低的值可使成员更不符合条件

默认情况下，优先级的值是1

【查看】

myrs:PRIMARY> rs.conf()
{
	"_id" : "myrs",
	"version" : 3,
	"protocolVersion" : NumberLong(1),
	"writeConcernMajorityJournalDefault" : true,
	"members" : [
		{
			"_id" : 0,
			"host" : "172.16.53.84:27017",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 1,
			"host" : "172.16.53.84:27018",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 2,
			"host" : "172.16.53.84:27019",
			"arbiterOnly" : true,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 0,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		}
	],
	"settings" : {
		"chainingAllowed" : true,
		"heartbeatIntervalMillis" : 2000,
		"heartbeatTimeoutSecs" : 10,
		"electionTimeoutMillis" : 10000,
		"catchUpTimeoutMillis" : -1,
		"catchUpTakeoverDelayMillis" : 30000,
		"getLastErrorModes" : {
			
		},
		"getLastErrorDefaults" : {
			"w" : 1,
			"wtimeout" : 0
		},
		"replicaSetId" : ObjectId("5e98072ba69725757421e2ab")
	}
}
myrs:PRIMARY>

可以看出，主节点和副本节点的优先级各为1，即，默认可以认为都已经有了一票。但选举节点，优先级是0，（要注意是，官方说了，选举节点的优先级必须是0，不能是别的值。即不具备选举权，但具有投票权）

既然有优先级，那就有办法修改，下面了解了解，因为一般情况下不会动这些

【步骤】

1）先将配置导入cfg变量

myrs:SECONDARY> cfg=rs.conf()

2）然后修改值（ID号默认从0开始）：

myrs:SECONDARY> cfg.members[1].priority=2

2

3）重新加载配置

myrs:SECONDARY> rs.reconfig(cfg) { "ok" : 1 }

稍等片刻会重新开始选举

springData 连接MongoDB（副本集）

副本集语法

mongodb://host1,host2,host3/articledb?
connect=replicaSet&slaveOk=true&replicaSet=副本集名字

其中：

slaveOk=true：开启副本节点读的功能，可实现读写分离。 connect=replicaSet：自动到副本集中选择读写的主机。如果slaveOK是打开的，则实现了读写分离

【注意】

主机必须是副本集中所有的主机，包括主节点、副本节点、仲裁节点。

完整的连接字符串的参考（了解）：

MongoDB客户端连接语法：

mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]]
[/[database][?options]]

mongodb:// 这是固定的格式，必须要指定
username:password@ 可选项，如果设置，在连接数据库服务器之后，驱动都会尝试登陆这个数据库
host1 必须的指定至少一个host, host1 是这个URI唯一要填写的。它指定了要连接服务器的地址。如果要连接复制集，请指定多个主机地址。
portX 可选的指定端口，如果不填，默认为27017
/database 如果指定username:password@，连接并验证登陆指定数据库。若不指定，默认打开 test 数据库。
?options 是连接选项。如果不使用/database，则前面需要加上/。所有连接选项都是键值对 name=value，键值对之间通过&或;（分号）隔开

测试故障

测试副本节点异常

关闭27018副本节点：发现，主节点和仲裁节点对27018的心跳失败。因为主节点还在，因此，没有触发投票选举。如果此时，在主节点写入数据。

这时候在主节点插入一条文档数据，再重启副节点，在副节点中查询，同样可以查到两条数据

主节点写入的数据，会自动同步给从节点。

测试主节点异常

关闭27017节点

发现，从节点和仲裁节点对27017的心跳失败，当失败超过10秒，此时因为没有主节点了，会自动发起投票。而副本节点只有27018，因此，候选人只有一个就是27018，开始投票。 27019向27018投了一票，27018本身自带一票，因此共两票，超过了“大多数” 27019是仲裁节点，没有选举权，27018不向其投票，其票数是0. 最终结果，27018成为主节点。具备读写功能。在27018写入数据查看。

从而实现了高可用。

测试仲裁节点和主节点都异常

先关掉仲裁节点27019、目前主节点27018 登录27017后，发现，27017仍然是从节点，副本集中没有主节点了，导致此时，副本集是只读状态，无法写入。为啥不选举了？因为27017的票数，没有获得大多数，即没有大于等于2，它只有默认的一票（优先级是1）如果要触发选举，随便加入一个成员即可。

如果只加入27019仲裁节点成员，则主节点一定是27017，因为没得选了，仲裁节点不参与选举，但参与投票。

如果只加入27018节点，会发起选举。因为27017和27018都是两票，则按照谁数据新，谁当主节点。

测试仲裁节点和从节点都异常

先关掉仲裁节点27019，关掉现在的副本节点27018 10秒后，27017主节点自动降级为副本节点。（服务降级）副本集不可写数据了，已经故障了。

用SpringData连接MongoDB测试案例

写了这么多基础知识，就和学mysql一样最终的目的就是学习通过代码来连接，下面就通过一个小小的案例来熟悉SpringDatamongodb

MongoDB创建文档数据

use articledb

try {  
    db.comment.insertMany([{
    "_id": "1",
    "articleid": "100001",
    "content": "我们不应该把清晨浪费在手机上，健康很重要",
    "userid": "1002",
    "nickname": "相忘于江湖",
    "createdatetime": new Date("2019-08- 05T22:08:15.522Z"),
    "likenum": NumberInt(1000),
    "state": "1"
    },
    {
        "_id": "2",
        "articleid": "100001",
        "content": "我夏天空腹喝凉开水，冬天喝温开水",
        "userid": "1005",
        "nickname": "伊人憔 悴",
        "createdatetime": new Date("2019-08-05T23:58:51.485Z"),
        "likenum": NumberInt(888),
        "state": "1"
    },
    {
        "_id": "3",
        "articleid": "100001",
        "content": "我一直喝凉开水，冬天夏天都喝。",
        "userid": "1004",
        "nickname": "杰克船 长",
        "createdatetime": new Date("2019-08-06T01:05:06.321Z"),
        "likenum": NumberInt(666),
        "state": "1"
    },
    {
        "_id": "4",
        "articleid": "100001",
        "content": "专家说不能空腹吃饭，影响健康。",
        "userid": "1003",
        "nickname": "凯 撒",
        "createdatetime": new Date("2019-08-06T08:18:35.288Z"),
        "likenum": NumberInt(2000),
        "state": "1"
    },
    {
        "_id": "5",
        "articleid": "100001",
        "content": "研究表明，刚烧开的水千万不能喝，因为烫 嘴。",
        "userid": "1003",
        "nickname": "凯撒",
        "createdatetime": new Date("2019-08- 06T11:01:02.521Z"),
        "likenum": NumberInt(3000),
        "state": "1"
    },
    {
        "_id": "6",
        "articleid": "100001",
        "content": "这是一条分页测试",
        "userid": "1004",
        "parentid":"3",
        "nickname": "凯撒",
        "createdatetime": new Date("2019-08- 06T11:01:02.521Z"),
        "likenum": NumberInt(3000),
        "state": "1"
    }
    ]);
} catch (e) { 
    print (e); 
}

db.comment.find()

【步骤一】

用idea 创建一个Springboot 项目名为，引入所需依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>

【步骤二】

添加application.yml 在这里配置 MongoDB的链接

spring:
  data:
    mongodb:
      database: articledb
      host: 116.62.102.168
      port: 27017
        #也可以使用uri连接
#      uri: mongodb://116.62.102.168:27019/articledb?connect=replicaSet&slaveOk=true&replicaSet=myrs

uri的解析： http://blog.hzxbk.vip/archives/mongodb%E9%AB%98%E7%BA%A7%E9%9B%86%E7%BE%A4%E5%92%8C%E5%AE%89%E5%85%A8#springdata-%E8%BF%9E%E6%8E%A5mongodb%E5%89%AF%E6%9C%AC%E9%9B%86

创建启动类

/**
 * @ClassName MongodbMainAppliction
 * @Description TODO
 * @Author hzx456
 * @Date 2020/4/16 12:27
 * @Version 1.0
 */
@SpringBootApplication
public class MongodbMainAppliction {
     public static void main(String[] args) {
             SpringApplication.run(MongodbMainAppliction.class,args);
         }
}

启动下看看有没有报错

【步骤三】

文章评论实体类的编写

/**
 * @ClassName Comment
 * @Description TODO
 * @Author hzx456
 * @Date 2020/4/16 12:34
 * @Version 1.0
 * 把一个java类声明为mongodb的文档，可以通过collection参数指定这个类对应的文档。
 *
 *  若未加 @Document ，该 bean save 到 mongo 的 comment collection
 *  若添加 @Document ，则 save 到 comment collection
 */

@Data
@NoArgsConstructor
@AllArgsConstructor
//复合索引
@CompoundIndex( def = "{'userid': 1, 'nickname': -1}")//推荐用命令行的形式建索引
@Document(collection="comment")可以省略，如果省略，则默认使用类名小写映射集合
public class Comment {
    //主键标识，该属性的值会自动对应mongodb的主键字段"_id"，如果该属性名就叫“id”,则该注解可以省略，否则必须写
    //    @Id
    private String id;//主键
    //该属性对应mongodb的字段的名字，如果一致，则无需该注解
    @Field("content")
    private String content;//吐槽内容
    private Date publishtime;//发布日期
    //添加了一个单字段的索引
    @Indexed
    private String userid;//发布人ID
    private String nickname;//昵称
    private LocalDateTime createdatetime;//评论的日期时间
    private Integer likenum;//点赞数
    private Integer replynum;//回复数
    private String state;//状态
    private String parentid;//上级ID
    private String articleid;

    @Override
    public String toString() {
        return "Comment{" +
                "id='" + id + '\'' +
                ", content='" + content + '\'' +
                ", publishtime=" + publishtime +
                ", userid='" + userid + '\'' +
                ", nickname='" + nickname + '\'' +
                ", createdatetime=" + createdatetime +
                ", likenum=" + likenum +
                ", replynum=" + replynum +
                ", state='" + state + '\'' +
                ", parentid='" + parentid + '\'' +
                ", articleid='" + articleid + '\'' +
                '}';
    }
}

【说明】

索引可以大大提升查询效率，一般在查询字段上添加索引，索引的添加可以通过Mongo的命令来添加，也可以在Java的实体类中通过注解添加。

单字段索引@Indexed

复合索引注解@CompoundIndex

【步骤四】

文章评论的基本增删改查

dao层

package com.hzx.dao;

import com.hzx.entity.Comment;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;

/**
 * @Author hzx456
 * @Date 2020/4/16 12:47
 * @Version 1.0
 */
public interface CommentRepository extends MongoRepository<Comment,String> {
    Page<Comment> findByParentid(String parentId, Pageable page);
}

service层

package com.hzx.service;

import com.hzx.dao.CommentRepository;
import com.hzx.entity.Comment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @ClassName CommentService
 * @Description TODO
 * @Author hzx456
 * @Date 2020/4/16 12:48
 * @Version 1.0
 */
@Service
public class CommentService {

    @Autowired
    private CommentRepository commentRepository;

    @Autowired
    private MongoTemplate mongoTemplate;



    /**
     * 保存一个评论
     * @param comment
     */
    public void saveComment(Comment comment){
        //如果需要自定义主键，可以在这里指定主键；如果不指定主键，MongoDB会自动生成主键
        //设置一些默认初始值。。。
        //调用dao
        commentRepository.save(comment);
    }

    /**
     * 更新评论
     * @param comment
     */
    public void updateComment(Comment comment){
        //调用dao
        commentRepository.save(comment);
    }

    /**
     * 根据id删除评论
     * @param id
     */
    public void deleteCommentById(String id){
        //调用dao
        commentRepository.deleteById(id);
    }

    /**
     * 查询所有评论
     * @return
     */
    public List<Comment> findCommentList(){
        //调用dao
        return commentRepository.findAll();
    }

    /**
     * 根据id查询评论
     * @param id
     * @return
     */
    public Comment findCommentById(String id){
        //调用dao
        return commentRepository.findById(id).get();
    }


    public Page<Comment> findCommentListByParentid(String parentid, int page, int size) {
        return commentRepository.findByParentid(parentid, PageRequest.of(page-1,size));
    }

    public void updateCommentLikenum(String id){

        //  查询条件
        Query query = Query.query(Criteria.where("_id").is(id));
        //  更新条件
        Update update = new Update();
        update.inc("likenum");
        mongoTemplate.updateFirst(query,update,Comment.class);
    }



}

【步骤五】

junit测试

package com.hzx;

import com.hzx.entity.Comment;
import com.hzx.service.CommentService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/**
 * @ClassName CommentServiceTest
 * @Description TODO
 * @Author hzx456
 * @Date 2020/4/16 12:55
 * @Version 1.0
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class CommentServiceTest {
    @Resource
    private CommentService commentService;
	
    @Test
    public void testFindCommentList() {
        List<Comment> commentList = commentService.findCommentList();
       commentList.forEach(System.out::println);
    }
    @Test
    public void testFindCommentById() {
        Comment commentById = commentService.findCommentById("1");
        System.out.println(commentById);
    }

    @Test
    public void testSaveComment(){
        Comment comment=new Comment();
        comment.setArticleid("100000");
        comment.setContent("测试添加的数据");
        comment.setCreatedatetime(LocalDateTime.now());
        comment.setUserid("1006");
        comment.setNickname("温柔的兴哥哥");
        comment.setState("1");
        comment.setLikenum(0);
        comment.setReplynum(0);
        commentService.saveComment(comment);
    }

    @Test
    public void testFindCommentListByParentid() {
        Page<Comment> page = commentService.findCommentListByParentid("3", 1, 2);
        System.out.println(page.getTotalElements());
        System.out.println(page.getContent());
    }

    @Test
    public void testUpdateCommentLikenum() {
        commentService.updateCommentLikenum("5e97ea223ca05e52300a93df");
    }

}

文章目录结构：

d(String parentid, int page, int size) {
return commentRepository.findByParentid(parentid, PageRequest.of(page-1,size));
}

public void updateCommentLikenum(String id){

    //  查询条件
    Query query = Query.query(Criteria.where("_id").is(id));
    //  更新条件
    Update update = new Update();
    update.inc("likenum");
    mongoTemplate.updateFirst(query,update,Comment.class);
}

}


### 【步骤五】

junit测试 

```java
package com.hzx;

import com.hzx.entity.Comment;
import com.hzx.service.CommentService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/**
 * @ClassName CommentServiceTest
 * @Description TODO
 * @Author hzx456
 * @Date 2020/4/16 12:55
 * @Version 1.0
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class CommentServiceTest {
    @Resource
    private CommentService commentService;
	
    @Test
    public void testFindCommentList() {
        List<Comment> commentList = commentService.findCommentList();
       commentList.forEach(System.out::println);
    }
    @Test
    public void testFindCommentById() {
        Comment commentById = commentService.findCommentById("1");
        System.out.println(commentById);
    }

    @Test
    public void testSaveComment(){
        Comment comment=new Comment();
        comment.setArticleid("100000");
        comment.setContent("测试添加的数据");
        comment.setCreatedatetime(LocalDateTime.now());
        comment.setUserid("1006");
        comment.setNickname("温柔的兴哥哥");
        comment.setState("1");
        comment.setLikenum(0);
        comment.setReplynum(0);
        commentService.saveComment(comment);
    }

    @Test
    public void testFindCommentListByParentid() {
        Page<Comment> page = commentService.findCommentListByParentid("3", 1, 2);
        System.out.println(page.getTotalElements());
        System.out.println(page.getContent());
    }

    @Test
    public void testUpdateCommentLikenum() {
        commentService.updateCommentLikenum("5e97ea223ca05e52300a93df");
    }

}

文章目录结构：

Heri.MG

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MongoDB快速入门

MongoDB简介官网：https://www.mongodb.com/什么是MongoDB ?MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。在高负载的情况下，添加更多的节点，可以保证服务器性能。MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对...
复制链接

扫一扫

专栏目录