MongoDB保姆级指南(上)：七万字从零到进阶，助你掌握又一款强大的NoSQL！-阿里云开发者社区

引言

在早期的程序开发过程中，单体+MySQL足以应对业务需求，可随着业务不断发展，系统架构演变成分布式，而数据存储的需求亦是多样化，单纯依赖于MySQL或其他某一款关系型数据库，再也难以支撑系统的存储需求，于是，现如今一个复杂系统中，可能会牵扯到MySQL、Redis、ES、MongoDB、FastDFS、CDH……多种数据存储产品，根据不同的业务特性、响应要求，会将数据存储在不同组件中以满足系统需要。

在之前的文章中，关于数据存储这个方向，咱们用[全解MySQL专栏》深入剖析了MySQL这个关系型数据库，也单开过《Redis综述篇》来讲述Redis这个非关系型数据库，可是数据存储太过庞大，表现优异的产品还有很多，本文咱们聊聊MongoDB。

MongoDB是数据库家族中的一员，是一款专为扩展性、高性能和高可用而设计的数据库，它可以从单节点部署扩展到大型、复杂的多数据中心架构，也能提供高性能的数据读写操作；而且提供了数据复制、无感知的故障自动选主等功能，从而实现数据节点高可用。

但MongoDB并不是一款关系型数据库，而是一款基于“分布式存储”的非关系型数据库（NoSQL），由C++编写而成。它与Redis、Memcached这类传统NoSQL不同，MongoDB具有半结构化特性，啥意思呢？下面仔细聊聊。

声明：相较于以往技术文，本篇内容不算特别有趣，如若各位小伙伴有足够的摸鱼时间，可以玩玩作为技术储备；反之，如果目前时间不算充裕，可以收藏等到往后有所需要时再回来阅读~

关于MongoDB相关的文章，总共会分为上中下三篇，同时为了屏蔽语言之间的差异，前面两篇都会使用MongoDB原生的语法进行阐述，为此，无论你是Java，还是PHP、Node、Go、Python、C#……任何语言的开发者，都可以畅通无阻般阅读！

一、MongoDB快速入门

MongoDB的数据存储格式非常松散，采用“无模式、半结构化”的思想，通过BSON格式来存储数据。

BSON的全称为Binary JSON，翻译过来是指二进制的JSON格式，在存储和扫描效率高于原始版JSON，但是对空间的占用会更高。同时，BSON在JSON基础之上，多加了一些类型及元数据描述，具体可参考《MongoDB官网-BSON类型》。

之所以说MongoDB具有半结构化特性，这是由于BSON拥有着JSON的特性，JSON天生具备结构性，可以便捷的存储复杂的结构数据。但是Mongo的数据结构又特别灵活，没有关系型数据库那种“强结构化”的规范。

强结构化：所有数据入库前，库中必须先定义好结构，并且入库的数据，每个值要与定义好的字段一一对应，当结构发生变更时，再按原有结构插入数据则会报错，必须同步修改插入的数据，使用起来特别“繁琐”。

MongoDB中用BSON来存储数据，而BSON是一种文档，所以它也被称之为：文档型数据库，文档由一或多个K-V键值对组成，其中的Key只能由字符串表示，值则可以是任意类型，如数组、字符串、数值……。简单来说，你可以把MongoDB中的一个文档，看做成一个JSON对象。

上面提到“文档”这个概念，初次接触的伙伴或许会疑惑，这里我们与MySQL数据库对比一下，其实两者的结构很类似，如下：

MySQL	MongoDB
数据库（`DataBase`）	数据库（`DataBase`）
数据表（`Table`）	数据集合（`Collection`）
数据行（`Row`）	数据文档（`Document`）
列/字段（`Column`）	字段（`Field`）
索引（`Index`）	索引（`Index`）

MongoDB中的一个集合，对应MySQL中的一张表；一个文档对应着MySQL一行数据……，层级结构的理念相同，只不过叫法和细节不同。当然，光看概念也很难帮大家认识Mongo，接下来快速搭建下环境，实操理解的效果更佳。

1.1、MongoDB环境搭建

MongoDB分为免费社区版、收费企业版，虽说前者功能有所阉割，但好在免费，并且可以满足大多数项目需求，这里咱们先去MongoDB官网-社区版选择对应的操作系统、版本下载安装包，同Redis一样，版本号的第二位数，为奇数代表开发版，为偶数代表是稳定版，我这里选择下载CentOS7-x64-6.0.8-tgz版的安装包。

❶创建MongoDB目录，并通过工具上传安装包至服务器（或虚拟机）：

[root@~]# mkdir /soft && mkdir /soft/mongodb/
[root@~]# cd /soft/mongodb/

如果不想这么麻烦，也可以用wget命令在线拉取安装包：

[root@~]# wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-6.0.8.tgz

没有wget命令，可以通过yum安装一下：

[root@~]# yum -y install wget

❷解压相应目录下的安装包，并重命名解压后的目录：

[root@~]# tar -xvzf mongodb-linux-x86_64-rhel70-6.0.8.tgz
[root@~]# mv mongodb-linux-x86_64-rhel70-6.0.8 mongodb6.0.8

由于我们下载的是压缩包，属于开箱即用版，无需任何额外配置。但为了方便启动，咱们可以将bin目录拷贝出来：

[root@~]# cp -a /soft/mongodb/mongodb6.0.8/bin /soft/mongodb/bin

❸创建单机版MongoDB存储配置文件、数据、日志的目录：

[root@~]# mkdir /soft/mongodb/data && 
          mkdir /soft/mongodb/log && 
          mkdir /soft/mongodb/conf && 
          mkdir /soft/mongodb/data/standalone && 
          mkdir /soft/mongodb/log/standalone && 
          mkdir /soft/mongodb/conf/standalone

❹编写MongoDB核心配置文件（没有会自动创建）：

[root@~]# vi /soft/mongodb/conf/standalone/mongodb.conf

这里大家可以直接复制下述yaml配置，配置的具体含义可参考注释（也支持传统.conf形式配置）：

# MongoDB日志存储相关配置
systemLog:
    # 将所有日志写到指定文件中
    destination: file
    # 记录所有日志信息的文件路径
    path: "/soft/mongodb/log/standalone/mongodb.log"
    # 当服务重启时，将新日志以追加形式写到现有日志尾部
    logAppend: true
# 指定MongoDB存储数据的目录
storage:
    dbPath: "/soft/mongodb/data/standalone"
# 以后台进程方式运行MongoDB服务
processManagement:
    fork: true
# ------ MongoDB网络相关配置 ------
net:
    # 绑定服务实例的IP，默认是localhost，0.0.0.0表示任意IP（线上换成具体IP）
    bindIp: 0.0.0.0
    #绑定的端口，默认是27017
    port: 27017

复制时记住把数据、日志的目录，改成自己前面新建的，接着按下Esc，输入:wq保存退出。

❺启动Mongo服务，这里和Redis类似，都是以启动脚本+配置文件的方式：

[root@~]# /soft/mongodb/bin/mongod -f /soft/mongodb/conf/standalone/mongodb.conf

看到successfully表示启动成功，大家也可以通过ps命令来查看后台进程，确保正常启动：

[root@~]# ps aux | grep mongod

❻连接MongoDB测试是否可以正常使用，不过下述命令只适用于6.x以下：

[root@~]# /soft/mongodb/bin/mongo -port 27017

到了MongoDB6.x版本，官方不再默认内置Shell客户端工具，想要使用则需额外下载：官方Shell工具，这里咱们照样以wget方式下载：

[root@~]# wget https://downloads.mongodb.com/compass/mongosh-1.10.3-linux-x64.tgz

接着将其解压，并拷贝bin目录下的Shell工具，放到原本的bin目录中：

[root@~]# tar -zxvf mongosh-1.10.3-linux-x64.tgz
[root@~]# cp /soft/mongodb/mongosh-1.10.3-linux-x64/bin/mongosh /soft/mongodb/bin/

然后再通过mongosh来连接测试：

[root@~]# /soft/mongodb/bin/mongosh -port 27017
test> show dbs;

如果上述操作执行完成后，能正常显示三个默认库，说明MongoDB安装成功。

❼关闭MongoDB服务，这里有三种方式：

# 1.通过启动项来关闭
[root@~]# /soft/mongodb/bin/mongod --shutdown -f /soft/mongodb/conf/standalone/mongodb.conf

# 2.先通过客户端连接MongoDB服务，再进入admin库关闭（执行完后客户端会报连接出错）
[root@~]# /soft/mongodb/bin/mongosh -port 27017
test> use admin;
test> db.shutdownServer();

# 3.通过kill命令+进程号强杀进程
[root@~]# kill -9 [pid]

一般推荐使用前面两种，因为kill强杀进程，可能会导致数据损坏，如果损坏则需手动修复：

# 先删除数据目录下的所有锁文件
[root@~]# rm -rf /soft/mongodb/data/standalone/*.lock
# 再通过启动项对数据目录进行修复
[root@~]# /soft/mongodb/bin/mongod  --repair --dbpath=/soft/mongodb/data/standalone

❽单纯的命令行不便于操作，所以通常会使用可视化工具来操作，而MongoDB官方提供了一个可视化工具：MongoDB Compass，可以先点击>>官网下载地址<<，直接下载解压即用的ZIP包。

当然，其实官方这款工具并不算好用，如果你有Navicat Premium（黄色图标那款），可以直接通过Navicat来连接MongoDB操作。

❾为了外部可以连接，需要开放MongoDB端口、更新防火墙（关闭防火墙也行）：

[root@~]# firewall-cmd --zone=public --add-port=27017/tcp --permanent
[root@~]# firewall-cmd --reload
[root@~]# firewall-cmd --zone=public --list-ports

开放端口后，就可以通过可视化工具来连接操作了（如果你通过Navicat工具连接，是看不到三个默认库的）。

1.2、MongoDB增删改查

搭建好MongoDB的环境后，接着学习一下最基本的CRUD操作，首先声明：MongoDB中的多数操作都带有隐式创建特性，啥意思呢？好比你使用一个数据库，如果没有则会自动创建；使用一个集合时，没有也会自动创建……

这里咱们先创建一个数据库和集合，如下：

// 切换到zhuzi库，没有会自动创建
use zhuzi;
// 向xiong_mao集合插入一条数据（没有集合会自动创建）
db.xiong_mao.insert({_id:1});

和Python一样，最后的分号可写可不写，不过建议写上，以此增加代码的可读性。

现在继续往xiong_mao集合中插入两条数据：

db.xiong_mao.insert({_id:2, name:"肥肥", age:3, hobby:"竹子"});
db.xiong_mao.insert({name:"花花", color:"黑白色"});

此时大家会发现，这两条数据同样可以插入成功，前面咱们并没有像使用MySQL一样，先定义好表结构！从这里就印证了一开始所说的“无模式”特点，接着学学查询：

// 查询xiong_mao集合的所有数据
db.xiong_mao.find();

// ------- 返回结果 ----------
[
  { _id: 1 },
  { _id: 2, name: '肥肥', age: 3, hobby: '竹子' },
  {
    _id: ObjectId("64d0b843fa3b00006f0044d6"),
    name: '花花',
    color: '黑白色'
  }
]

注意观察第三条数据，在插入时我们并未指定_id值，可为啥还是有这个字段呢？因为_id是mongoDB的默认字段，每个文档（每行数据）必须要有该字段，如果插入时未指定该字段，会自动生成一个类似于雪花ID的ObjectId值，mongoDB会使用_id来维护数据的存储结构（类似于InnoDB的隐藏列-row_id，后面再细聊）。

如何根据指定条件查询数据呢？如下：

// 查询_id=2的数据
db.xiong_mao.find({_id:2});
// 查询name=花花的数据
db.xiong_mao.find({name:"花花"});

大家会发现，前面我们以Json形式将数据插入到集合后，在查询时，咱们可以直接通过Json中的字段名来操作，这也就印证了最开始所说的“半结构化”特征，因为像Redis、Memcached这类NoSQL，虽然也能把数据Json序列化后存进去，但想要操作时，只能先读出来再反序列化成对象，不能直接对序列化后的Json字符串进行操作！

最后再来学习一下修改、删除操作：

// 将_id=2的数据，爱好修改为：吃竹子、睡觉
db.xiong_mao.update({_id:2},{hobby:"吃竹子、睡觉"});
// 上面那种方式，会导致其他字段变null，要记得加{$set:}，表示局部修改
db.xiong_mao.update({_id:2},{$set:{hobby:"吃竹子、睡觉"}});

// 删除_id=1的数据
db.xiong_mao.remove({_id:1});

OK，我们过了一下最简单的CRUD操作，这里主要是让大家先熟悉下语法，诸位也可以自行多练习一下。

相较于SQL的语法来说，MongoDB的语法显得有点反人类；反观同为NoSQL的Redis，它的命令则显得简洁清爽许多。当然，熟悉JS的小伙伴，接触这个语法不算太难，毕竟这就是JS的语法，如果只是纯后端的开发者，想适应过来需要一定的练习。

1.3、库与集合的命令

熟悉了基本的CRUD语法后，进阶一点的语法咱们放到后面慢慢学，这里先熟悉下常用的库、集合的命令：

查询所有数据库：show dbs;或show databases;
切换/创建数据库：use 库名;
查看目前所在的数据库：db;
查看MongoDB目前的连接信息：db.currentOp();
查看当前数据库的统计信息：db.stats();
删除数据库：db.dropDatabase("库名");
查看库中的所有集合：show collections;或show tables;
显式创建集合：db.createCollection("集合名");
查看集合统计信息：db.集合名.stats();
查看集合的数据大小：db.集合名.totalSize();
删除指定集合：db.集合名.drop();

上述这些管理数据库、集合的命令只需简单了解，毕竟大多情况下，都可以通过可视化工具来完成这些操作，所以下面开始学习MongoDB中的文档操作命令。

二、MongoDB渐悉

下次再次从CRUD操作开始，对MongoDB的命令建立全面认知，先来看看新增/插入操作。

2.1、新增操作

MongoDB中提供了三个显式向集合插入数据的方法：

// 向集合插入单条或多条数据（需要用[]来包裹多个文档）
db.xiong_mao.insert([
    {_id:4, name:"黑熊", age:3, food:{name:"黄金竹", grade:"S"}},
    {_id:5, name:"白熊", age:4, food:{name:"翠绿竹", grade:"B"}}
]);

// 向集合插入单条数据
db.xiong_mao.insertOne({_id:6, name:"棕熊"});

// 向集合批量插入多条数据
db.xiong_mao.insertMany([
    {_id:7, name:"红熊", age:2, food:{name:"白玉竹", grade:"S"}},
    {_id:8, name:"粉熊", age:6, food:{name:"翡翠竹", grade:"A"}}
]);

从案例中可发现，每个字段可以无限嵌套json。同时，这三个insert方法都有两个可选项，如下：

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

writeConcern表示嵌套文档，这个咱们后续再细说；ordered表示本次是否按顺序插入，2.6以上版本默认为true，表示按指定的顺序插入数据。

除开上面三个常用的插入方法外，MongoDB还可以通过其他方式实现数据新增，如：

const bulkOps = [
  {insertOne: {document: {_id: 9, name: "黄熊"}}},
  {insertOne: {document: {_id: 10, name: "灰熊"}}}
];
db.xiong_mao.bulkWrite(bulkOps);

bulkWrite()方法可以传入一个操作数组，MongoDB会按照给定的操作顺序依次执行，其中还可以放修改、删除等MongoDB支持的操作。最后，还能通过修改命令，向集合中隐式插入数据，在使用修改命令时，将upsert设为true即可（后面会演示）。

2.2、删除操作

MongoDB中的删除命令，有remove、delete两类方法：

// 根据指定条件删除集合中的数据
db.xiong_mao.remove({_id:1});

// 删除集合中的所有数据（不写条件即可）
db.xiong_mao.remove({});

// 根据条件删除单条数据（有多条数据满足条件时，只会删第一条）
db.xiong_mao.deleteOne({_id:6, name:"棕熊"});

// 根据条件删除多条数据（满足条件的全部删除）
db.xiong_mao.deleteMany({name:"红熊"});

// 根据条件删除满足条件的第一条数据，并返回删除后的数据
db.xiong_mao.findOneAndDelete({_id:2});

当然，这里只列出了根据等值条件删除的操作，类似于SQL中的<、>、in、or、and……怎么写呢？这些放到后续的查询操作中讲解，因为条件过滤器在MongoDB中是通用的。

2.3、修改操作

想要更新一个集合中的数据时，可以使用update、replace操作：

// 根据条件修改集合中的单条数据（多条数据满足条件时，只修改第一条）
db.xiong_mao.updateOne({_id:7}, {$set:{name:"英熊"}});

// 根据条件修改集合中的多条数据（color字段不存在时，自动创建并赋值）
db.xiong_mao.updateMany({age:3}, {$set:{color:"黑白色"}});

// 根据条件替换掉单行数据（使用新数据替换老的数据）
db.xiong_mao.replaceOne({_id:6}, {name:"棕熊", age:3, color:"棕色"});

// 根据条件修改集合中的单条数据（可以通过.分割的形式，修改嵌套的json）
db.xiong_mao.update({_id:8}, {$set:{age:3, "food.grade":"C"}});

// 根据条件修改集合中的单/多条数据（如果想通过update更新多条，需要使用multi）
db.xiong_mao.update({age:3}, {$set:{hobby:"竹子"}},{multi:true});

修改操作默认是全量修改，即使用指定的值，覆盖原有的整条数据，如果有些字段值在修改时未给定，则会变为null（消失）。为此，如若只想修改某几个字段，记得在前面加上$set选项。

当然，这里也仅是用_id在做等值条件修改，后面讲完查询操作后，大家可以自行套入各种复杂条件进行修改。

还记得提过的“修改时隐式新增”嘛？演示一下：

db.xiong_mao.update(
    {_id:11}, 
    {name:"紫熊", age:3, food:{name:"明月竹", grade:"A"}}, 
    {upsert:true}
);

在修改时，只需指定upsert:true即可，这样在未匹配到对应条件的数据时，会将本次修改的数据插入到集合中，而前面演示的所有修改方法，都支持指定upsert选项。

修改操作除开上述方法外，还可以通过findAndModify()、findOneAndUpdate()、findOneAndReplace()方法来修改，如：

db.xiong_mao.findAndModify({
  query:{_id:8},
  update:{$set:{color: "紫色"}},
  new: true
});

这些findAnd开头的修改方法，会根据条件修改满足条件的第一条数据，修改完之后，如果new指定为true，则会返回修改后的数据，如果为false，则返回修改前的数据（其余两个方法类似，不再继续演示）。

2.4、查询操作

增删改查的前三项过完了，接着来说说查询操作，这应该属于最复杂的一项，咱们一点点开始接触。

2.4.1、基本查询语句

// 查询集合所有数据
db.xiong_mao.find();

// 根据单个等值条件查询数据
db.xiong_mao.find({_id:2});

// 查询满足多个等值条件的数据（and查询）
db.xiong_mao.find({age:3, "food.grade":"S"});

// 查询满足任意一个条件的数据（or查询）
db.xiong_mao.find({$or: [{age:2}, {"food.grade":"S"}]});

// 查询单字段满足任意一个条件的数据（in查询）
db.xiong_mao.find({age:{$in: [2, 4]}});

// 查询颜色为黑白色，并且年龄小于5岁的数据
db.xiong_mao.find({color:"黑白色", age:{$lt: 5}});

// 查询爱好为竹子，或id大于9的数据
db.xiong_mao.find({$or: [{hobby:"竹子"}, {_id: {$gt:9}}]});

// 查询id小于等于5，并且（age大于等于2 或 name为肥肥）的数据
db.xiong_mao.find({
    _id:{$lte:5}, 
    $or: [{age: {$gte:2}}, {name:"肥肥"}]
});

// 查询name不为“白熊” 或 age 不大于 2 的数据
db.xiong_mao.find({$nor: [{name:"白熊"}, {age:{$gt:2}}]});

// 查询id在3~5之间的数据（between and范围查询）
db.xiong_mao.find({$and: [{_id:{$gte:3}}, {_id:{$lte:5}}]});

// 查询name以“粉”开头的数据（like右模糊查询）
db.xiong_mao.find({name:/^粉/});

上表仅仅只列出了一些在SQL中比较常见的，实则MongoDB提供了几百个操作符，以此来满足各类场景下的需求，如果你想要详细了解，可以参考MongoDB官网-Operators，当然，如果你英语阅读能力欠佳，可以参考MongoDB中文网-运算符。

接着来看看其他查询的语法：

// 对指定字段去重，并返回去重后的字段值列表
db.xiong_mao.distinct("age");

// 根据条件统计集合内的数据行数
db.xiong_mao.count({age:3});

// 根据条件进行分页查询（limit写行数，skip写跳过前面多少条）
db.xiong_mao.find({_id:{$lt:6}}).skip(0).limit(2); // 第一页
db.xiong_mao.find({_id:{$lt:6}}).skip(2).limit(2); // 第二页

// 根据指定字段进行排序查询（order by查询）
// 根据年龄升序，年龄相同根据id降序（1：升序，-1：降序）
db.xiong_mao.find().sort({age:1, _id:-1});

// 投影查询：只返回指定的字段（0表示不返回，1代表返回）
db.xiong_mao.find({color:"黑白色"}, {_id:0, name:1, color:1});

这里又列出了一些SQL中经常执行的操作，如统计、去重、排序、分页、投影查询等，和SQL一样，不同类型的函数，执行的优先级不一样，例如：

db.xiong_mao.find({_id:{$lt:6}}).limit(2).skip(2).sort({_id:-1}).count();

这条查询语句中，包含了limilt()、skip()、sort()、count()四个方法，可实际的执行顺序，跟书写的顺序无关，这些方法同时存在时，执行的优先级为：sort() > skip() > limilt() > count()。

2.4.2、聚合管道查询

好了，如果你想要实现更复杂的查询操作，则可以通过MongoDB提供的聚合管道来完成，语法如下：

db.collection.aggregate(
   pipeline: [ <stage>, <...> ],
   options: {
     explain: <boolean>,
     allowDiskUse: <boolean>,
     cursor: <document>,
     maxTimeMS: <int>,
     bypassDocumentValidation: <boolean>,
     readConcern: <document>,
     collation: <document>,
     hint: <string or document>,
     comment: <any>,
     writeConcern: <document>,
     let: <document> // Added in MongoDB 5.0
   }
);

聚合管道方法接收两个入参，第一个是数组型的聚合操作，第二个是可选项，先解释下常用的选项：

explain：传true表示返回聚合管道的详细执行计划；
allowDiskUse：是否允许使用硬盘进行聚合操作，内存不足时使用磁盘临时文件进行计算；
maxTimeMS：指定聚合操作的最大执行时间（单位ms），超时会被强制终止；
hint：显式指定使用那些索引进行聚合操作；

简单了解几个常用选项后，我们来重点关注一下pipeline参数，使用方式如下：

db.collection.aggregate([
  // 阶段1
  {$stage1: { /* 阶段1的操作 */ }},
  // 阶段2
  {$stage2: { /* 阶段2的操作 */ }},
  // ...
]);

观察上述语法，首先咱们需要指定操作符，这是为了声明当前阶段的类型，例如$group，接着可以指定每个阶段具体要做的事情。同时，聚合管道中的每个阶段，都会将上一阶段输出的数据，视为当前阶段输入的数据，和Stream流类似，下面上些例子理解，如下：

/* 按年龄进行分组，并统计各组的数量（没有age字段的数据统计到一组） */
db.xiong_mao.aggregate([
    // 1：通过$group基于age分组，通过$sum实现对各组+1的操作
    {$group: {_id:"$age", count: {$sum:1}}},
    // 2：基于前面的_id（原age字段）进行排序，1代表正序
    {$sort: {_id:1}}
]);

/* 按年龄进行分组，并得出每组最大的_id值 */
db.xiong_mao.aggregate([
    // 1：先基于age字段分组，并通过$max得到最大的id，存到max_id字段中
    {$group: {_id:"$age", max_id: {$max:"$_id"}}},
    // 2：按照前面的_id（原age字段）进行排序，-1代表倒序
    {$sort: {_id: -1}}
]);

/* 过滤掉食物为空的数据，并按食物等级分组，返回每组_id最大的熊猫姓名 */
db.xiong_mao.aggregate([
    // 1：通过$match操作符过滤food不存在的数据
    {$match: {food: {$exists:true}}},
    // 2：通过$sort操作符，基于_id字段进行倒排序
    {$sort: {_id: -1}},
    // 3：通过$group基于食物等级分组，并通过$max得到_id最大的数据，
    // 并通过$first拿到分组后第一条数据（_id最大）的name值
    {$group: {_id:"$food.grade", max_id: {$max:"$_id"}, name:{$first: "$name"}}},
    // 4：最后通过$project操作符，只显示_id（原food.grade）、name字段
    {$project: {_id:"$_id", name:1}}
]);

上面举了三个简单的聚合操作例子，但相信对于绝大多数刚接触的小伙伴来说，这些语句看起来十分头大，一眼望过去全都是符号+符号，这是因为MongoDB中，使用操作符代替了SQL中的函数与关键字，所以越是复杂的场景，使用到的操作符越多，对传统型的SQL Boy来说，可读性会越差~

当然，上面列出的仅是沧海一粟，MongoDB的聚合管道中可用的操作符有几百个，不管是SQL中有的，还是没有的功能/函数，都能找到对应的操作符代替，具体大家可以参考MongoDB官网-Aggregation Pipeline Operators，或MongoDB中文网-聚合管道操作符。

话归正题，咱们来稍微解读一下前面写出的聚合管道查询语句，先拿最简单的第一条来说：

/* 按年龄进行分组，并统计各组的数量 */
db.xiong_mao.aggregate([
    {$group: {_id:"$age", count: {$sum:1}}},
    {$sort: {_id:1}}
]);

在第一阶段中，使用$group操作符来完成分组动作，其中_id并不是原数据中的_id，而是代表想聚合的数据主键，上面的需求想基于年龄分组，所以_id设置为$age即可。

注意：在聚合查询中，也会使用$来引用原数据中的字段，案例中的$age并不是一个操作符，而是获取原数据的age字段，这种方式也可以用来拿其他字段，如$name、$color……。

在第一阶段中，咱们还定义了一个count字段，这相当于SQL中的别名，该字段的值，则是由{$sum:1}统计得出的，这段逻辑相当于：

Map<Integer, Integer> groupMap = new HashMap<>();
for (XiongMao xm : xiongMaoList) {
   
   
    Integer age = xm.getAge();
    if (groupMap.get(age) == null) {
   
   
        groupMap.put(age, 1);
    } else {
   
   
        Integer count = groupMap.get(age) + 1;
        groupMap.put(age, count);
    }
}

第一阶段的分组统计工作完成后，接着会来到第二阶段，其中使用了$sort操作符，对_id字段进行了升序排序，不过这里要注意，因为第二阶段输入的数据，是第一阶段输出的数据，所以第二阶段的_id，实际上是原本的age字段，这意味着在对年龄做升序排序！

OK，相信经过这番解释后，大家对MongoDB的聚合管道操作有了一定理解，那接着继续看些案例加深印象（也可以尝试着自己练习练习）：

/* 多字段分组：按食物等级、颜色字段分组，并求出每组的年龄总和 */
db.xiong_mao.aggregate([
    // 1：_id中写多个字段，代表按多字段分组，接着通过$sum求和age字段
    {$group: {_id: {grade:"$food.grade", color:"$color"}, total_age: {$sum:"$age"}}}
]);

/* 分组后过滤：根据年龄分组，然后过滤掉数量小于3的组 */
db.xiong_mao.aggregate([
    // 1：先按年龄进行分组，并通过$sum:1对每组数量进行统计
    {$group: {_id: "$age", count: {$sum:1}}},
    // 2：通过$match操作符，保留数量>3的分组（过滤掉<3的分组）
    {$match: {count: {$gt:3}}}
]);

/* 分组计算：根据颜色分组，求出每组的数量、最大/最小/平均年龄、所有姓名、首/尾的姓名 */
db.xiong_mao.aggregate([
    // 1：按颜色分组
    {$group: {_id: "$color", 
        // 计算每组数量
        count: {$sum:1}, 
        // 计算每组最大年龄
        max_age: {$max: "$age"},
        // 计算每组最小年龄
        min_age: {$min: "$age"},
        // 计算每组平均年龄
        avg_age: {$avg: "$age"},
        // 通过$push把每组的姓名放入到集合中
        names: {$push:"$name"},
        // 获取每组第一个熊猫的姓名
        first_name: {$first: "$name"},
        // 获取每组最后一个熊猫的姓名
        last_name: {$last: "$name"}}}
]);

/* 分组后保留原数据，并基于原_id排序，然后跳过前3条数据，截取5条数据 */
db.xiong_mao.aggregate([
    // 1：先基于color分组，并通过$$ROOT引用原数据，将其保存到数组中
    {$group: {_id: "$color", xiong_mao_list: {$push: "$$ROOT"}}},
    // 2：通过$unwind操作符，将xiong_mao_list数组分解成一条条数据
    {$unwind: {path:'$xiong_mao_list', 
        // 使用index字段记录数组下标，preserveNullAndEmptyArrays可以保证不丢失数据
        includeArrayIndex:"index", preserveNullAndEmptyArrays: true}},
    // 3：基于分解后的_id字段进行排序，1代表升序
    {$sort: {"xiong_mao_list._id": 1}},
    // 4：通过$skip跳过前3条数据
    {$skip: 3},
    // 5：通过$limit获取5条数据
    {$limit: 5}
]);

/* 根据年龄进行判断，大于3岁显示成年、否则显示未成年（输出姓名、结果） */
db.xiong_mao.aggregate([
    // 1：通过$project操作符来完成投影输出
    {$project: {
      // 不显示_id字段，将name字段重命名为：“姓名”
      _id:0, 姓名:"$name",
      // 通过$cond实现逻辑运算，如果年龄>=3，显示成年，否则显示未成年
      result: {
        $cond: {
          if: {$gte: ["$age", 3]},
          then: "成年",
          else: "未成年"
    }}}}
]);

好了，关于聚合管道的案例，暂时就写到这里，想要学习其他操作符的使用，可以参考之前给出的官网链接。这里主要说明几点要素。

首先聚合管道的每个阶段，内存限制一般为100MB，如果超出这个限制，执行时会报错，因此当需要处理大型数据集时，记得把allowDiskUse选项置为true，允许MongoDB使用磁盘临时文件来完成计算。

其次呢，使用聚合管道时也要牢记，筛选、过滤类型的阶段，最好放到前面完成，这样有两个好处：一是可以快速将不需要的文档过滤掉，减少管道后续阶段的工作量；二是如果在$project、$group这类操作前执行$match，$match阶段可以使用索引，因为此时属于在操作原本的文档，索引自然不会失效，可如果放到$project、$group……后面再执行，原数据被改变后，前面的阶段会形成新的文档，并输出到$match阶段中，这时索引不一定能继续生效。

最后，按官网所说，除了$out、$merge和$geoNear这些阶段外，其他类型的所有阶段，都可以在管道中出现多次，这意味着MongoDB会比传统型SQL更强大，比如可以多次分组、筛选……，结合管道里的几百个操作符，你可以实现各种复杂场景下的聚合操作。

2.4.3、嵌套文档的增删改查

在关系型数据库中，我们可以通过树表、主子表等思想，抽象出各种结构以满足业务需求，举个例子理解，比如下单业务中，用户一笔订单可能会包含多个商品，所以会用主子表的思想，对订单数据进行存储，订单数据存到主表中、订单详情数据放到子表，两表之间通过主外键关联，后续可以通过join来查询、使用。

但由于MongoDB是无模式、半结构化的存储方式，因此无法像传统型数据库那样，通过主外键来关联不同表（集合），毕竟一个集合没有明确的字段定义，可以随意插入不同字段。那MongoDB又该如何满足树表、主子表这种业务的存储需求呢？答案是通过文档嵌套来代替！

在前面学习insert操作时，大家不难得知：MongoDB集合中的每个字段，可以继续嵌套Json对象，因为MongoDB本身就是以Json格式存储数据，所以只要是能用Json格式表达出来的数据，都可以放到集合中存储，比如：

db.xiong_mao.insert([
    {_id:12, name:"金熊", age:4, hobby:["吃饭","睡觉"], food:{name:"黄金竹", grade:"S"}}
]);

在插入数据时，字段的值可以放入普通类型，也可以放入数组、另一个Json对象，所以早期的MongoDB，推荐通过嵌入文档，来代替SQL中的join多表连接查询，前面举例提到的订单、订单详情这种一对多的主子关系，可以用如下方式代替：

/* 以下数据仅为示例，不要纠结订单数据的不完整性 */
db.order.insert([{
    _id: 1, 
    order_number: "x-20230811185422", 
    order_status: "已付款",
    pay_fee: 888.88, 
    pay_type: "他人代付",
    order_user_id: "2222222",
    pay_user_id:"11111111",
    pay_time: new Date(),
    order_details: [
        {order_detail_id:1, shop_id:6, shop_price:666.66, status:"待发货"},
        {order_detail_id:2, shop_id:2, shop_price:222.22, status:"待发货"}
    ]
}]);

这样，当需要查询一笔订单的详情记录时，就直接查询oder集合即可，因为订单详情数据存储在order_details字段中，这个是一个数组，每个数组的元素则是一条条Json格式的订单详情。

下面来聊聊嵌套文档的增删改查，这里跟操作普通文档有些许出入，如下：

/* 新增单条订单详情：通过order集合的update方法来实现 */
db.order.update(
    // 修改条件：修改_id=1的订单数据
    {_id: 1},
    // 通过$push操作符，往order_details中压入一条新记录
    {$push: {
      order_details: {
        order_detail_id: 3,
        shop_id: 4,
        shop_price: 444.44,
        status: "待发货"
        }
    }}
);

/* 新增多条订单详情记录 */
db.order.update(
  {_id: 1},
  {$push: {
      order_details: {
        // 这里使用$each操作符，声明本次要push多个元素
        $each: [
          {order_detail_id: 4, shop_id: 3, shop_price: 333.33, status: "待发货"},
          {order_detail_id: 5, shop_id: 1, shop_price: 111.11, status: "待发货"}
        ]
      }
    }}
);

/* 删除满足条件的订单详情数据 */
db.order.update(
  {_id: 1},
  // 通过$pull操作符，将order_details满足条件的数据弹出
  {$pull: {
      // 删除order_detail_id大于3的订单详情数据
      order_details: {order_detail_id: {$gt:3}}
    }
});

/* 修改单条满足条件的订单详情数据 */
db.order.update(
  // 这里给定了两个条件，订单ID=1，并且订单详情ID=1
  {_id: 1, "order_details.order_detail_id": 1},
  // 通过$set操作符，来对集合中的文档进行局部修改
  {$set: {
      // 将状态改为已发货，这里的$，表示数组中的当前元素，即条件匹配的数组元素
      "order_details.$.status": "已发货"
  }}
);

/* 修改多条满足条件的订单详情数据 */ 
db.order.update(
  // 先查询到订单ID=1的数据
  {_id: 1},
  {$set: {
      // 这里使用的是$[elem]占位符，代表着要更新的元素
      "order_details.$[elem].status": "已发货"
  }},
  // 这里定义了一个数组过滤器，会把满足条件的订单详情记录筛选出来
  {arrayFilters: [
        // 这里的elem代表数组中的元素，过滤条件为：订单详情ID=2、3的数据
        {"elem.order_detail_id": {$in: [2,3]}}
    ]}
);

/* 修改满足多个条件的单条数据 */
db.order.update(
  {
    // 这里是基于order_details字段在做条件过滤，可以跨文档（在不同数据行中筛选）
    order_details: {
      // $elemMatch操作符代表匹配多个条件
      $elemMatch: {
        status: "已发货",
        shop_id: 2
    }}
  },
  // 对满足多个条件的单条数据进行修改（要修改多条，参考上个案例的用法即可）
  {$set: {
      "order_details.$.status": "已签收"
  }}
);

/* 查询符合条件的单条数据 */
db.order.find(
    // 查询order_detail_id==1的订单详情数据
    {"order_details.order_detail_id":1}, 
    // 限制返回的字段，不返回_id，order_details.$表示只返回满足条件的订单详情数据
    {"_id":0, "order_details.$":1}
);

/* 查询满足多个条件的多条数据 */
db.order.aggregate([
    // 使用$project操作符完成投影查询
    {$project: {
      // 不返回_id字段
      _id: 0,
      // 只返回order_details字段
      order_details: {
        // 通过$filter操作符，实现按条件过滤数据
        $filter: {
          // 这里相当于for循环，$order_details是要遍历的数组，$detail是别名
          input: "$order_details",
          as: "detail",
          // 这里是过滤的条件，$and表示两个条件都需要满足
          cond: {
            $and: [
              // 返回order_detail_id>=1 && status为“已签收”的数据
              {$gte: ["$$detail.order_detail_id", 1]},
              {$eq: ["$$detail.status", "已签收"]}
            ]
          }
        }
    }}}
]);

好了，上面把嵌套文档的增删改查操作简单过了一遍，其实嵌入式文档的CRUD，都依赖于外部集合的CRUD方法完成，唯一有区别的地方就在于：我们需要结合$push、$pull、$elemMatch、$[elem]等各种数组操作符，来实现嵌入式文档的增删改查。不过如若只嵌入了一个文档，而不是一个文档数组时，操作的方法有有些不同，如下：

// 以之前xiong_mao集合中，id=1的这条数据为例
db.xiong_mao.insert({_id:1, name:"肥肥", age:3, hobby:"竹子"});

// 为其添加一个内嵌文档
db.xiong_mao.update(
    {_id:1},
    {$set: {food: {name:"帝王竹", grade:"A"}}}, 
    {upsert:true}
);

// 查询一次看看这条数据（此时可以看到内嵌文档已经被添加）
db.xiong_mao.find({_id:1});
{
    _id: 1,
    name: '肥肥',
    age: 3,
    hobby: '竹子',
    color: '黑白色',
    food: { name: '帝王竹', grade: 'A' }
}

// 修改内嵌文档中的某个字段值
db.xiong_mao.updateMany(
    {_id:1},
    // 修改单个字段，要用 . 的形式
    {$set: {"food.grade":"S"}}, 
    {upsert:true}
);

// 删除内嵌文档中的单个字段
db.xiong_mao.update(
    {_id:1},
    // 通过$unset操作符，将对应字段置为空即可
    {$unset:{"food.grade":""}},
    {upsert:true}
);

// 删除整个内嵌文档
db.xiong_mao.update(
    {_id:1},
    // 将整个内嵌文档字段置为空即可
    {$unset:{food:""}},
    {upsert:true}
);

ok，关于文档嵌入的内容咱们先就此打住，来思考一个问题：真的所有带有主外键关系的结构，都可以通过文档嵌入代替吗？

这个答案明显是NO，为什么？就拿咱们前面“订单-订单详情”例子中的商品来说，每一笔订单详情记录，都需要跟商品产生绑定关系吧？这时我们总不能把整个商品的数据，全部嵌入到订单详情的某个字段中吧？因为一个商品可以被多次购买！如果真按这样存，假设一个商品单月销量10W+，产生的10W+订单详情记录，难道都把这个商品的完整数据嵌入一次吗？显然不合理。

正因如此，有些场景下，咱们无法通过文档嵌入来代替原本的多表关联，所以MongoDB在3.2版本以后，也支持了多个集合之间关联查询，就类似于SQL中的join一样！只不过功能没SQL强大，并且必须在聚合管道中使用，下面一起来看看。

2.4.4、多个集合关联查询

现在假设有商店shop_store、商品product两个集合，数据如下：

db.shop_store.insertMany([
    {_id: 1, name: "熊猫高级会所", address:"地球市天上人间街道888号", grade:"五星"},
    {_id: 2, name: "竹子商店", address:"地球市绿竹林街道666号", grade:"五星"}
]);
db.product.insertMany([
    {_id:1, shop_store_id:1, name:"水", description:"能有效缓解口渴", price:2.00},
    {_id:2, shop_store_id:2, name:"米饭", description:"能有效缓解饥饿", price:1.00},
    {_id:3, shop_store_id:1, name:"香烟", description:"能有效缓解寂寞", price:88.88},
    {_id:4, shop_store_id:1, name:"酒", description:"能有效缓解忧愁", price:99.00},
    {_id:5, shop_store_id:1, name:"牛奶", description:"能帮助长身体", price:4.00},
    {_id:6, shop_store_id:2, name:"咖啡", description:"能有效缓解疲劳", price:9.99},
    {_id:7, shop_store_id:1, name:"棉衣", description:"能有效缓解寒冷", price:188.00},
    {_id:8, shop_store_id:2, name:"辣条", description:"能有效缓解嘴馋", price:5.00}
]);

在以外，为了实现数据的关联性，我们会直接将商店数据，嵌入到商品数据的某个字段中，而在目前的这个例子中，却是通过shop_store_id字段来关联商品所在的商店，查询时又该如何处理呢？如下：

db.shop_store.aggregate([
  {
    $lookup: {
      from: "product",
      localField: "_id",
      foreignField: "shop_store_id",
      as: "products"
    }
  }
]);

在上述代码中，使用了聚合管道中的$lookup操作符，来实现多个集合之间的关联查询，其中主要有四个参数：

from：要关联的集合名称，这里是用商店关联商品，所以写product；
localField：shop_store集合中用于关联的字段，这里是_id；
foreignField：product集合中用于关联的字段，这里是shop_store_id；
as：指定两个集合匹配的数据，要保存到的字段名称，这里写了products。

由于关联查询，也依靠于聚合管道来完成，为此大家可以在关联查询的前后，插入各种业务所需的阶段，以满足各种特殊场景下的需求，不过这里注意：关联查询结束后，驱动集（调用aggregate方法的集合）的字段会完整输出，而被驱动集的字段，会以Json对象的形式，放入到指定的字段中，最终形成一个Json数组，即案例中的products。

最后，如果你的需求中，需要关联并筛选数据，那么最好将筛选动作放到关联查询前面，尽可能的减小关联查询时的数据集，因为$lookup操作符，底层就是两个for循环，如果两个集合都有100W条数据，未做筛选直接关联查询，此时性能堪忧……

2.5、数据类型

关于CRUD操作相关的命令咱们就此打住，掌握上述那些基本够用了，下面来看看MongoDB中的数据类型。

看完前几个阶段的内容大家会发现，MongoDB的命令，用的其实就是JavaScript的语法，所以在数据类型这块，原生JS中支持的MongoDB几乎都支持，这里就简单列一下：

String：存储变长的字符串；
Number：存储整数或浮点型小数；
Boolean：存储true、flase两个布尔值；
Date：存储日期和时间；
Array：可以存储由任意类型组成的数组；
Embedded-Document：可以将其他结构的文档，嵌套到一个文档的字段中；
Binary：存储由0、1组成的二进制数据，如图像、音/视频等；
Code：MongoDB支持直接存储JavaScript代码；
Timestamp：存储格林威治时间（GMT）的时间戳；
GeoJSON：存储地理空间数据；
Text：存储大文本数据；

从上面列出的类型不难发现，其实这些数据，的的确确都是原生JS支持的类型~

2.6、事务与锁机制

MongoDB作为数据库家族的一员，自然也支持事务机制，只不过相较于InnoDB的事务机制而言，MongoDB事务方面并没有那么强大，这倒不是因为官方技术欠缺，而是由于MongoDB的定位是：大数据、高拓展、高可用、分布式，因此在实现事务时，不仅仅要考虑单机事务，而且需要考虑分布式事务，复杂度上来之后，自然无法做到MySQL-InnoDB那种单机事务的强大性。

这里也列出MongoDB事务方面的改进过程，如下：

3.0版本中，引入WiredTiger存储引擎，开始支持单文档事务；
4.0版本中，开始支持多文档事务，以及副本集（主从复制）架构下的事务；
4.2版本中，开始支持分片集群、分片式多副本集架构下的事务。

再次类比MySQL，MongoDB支持了分片集群中的事务，而MySQL只支持主从集群下的事务，并不支持分库环境下的事务，在这方面，MongoDB强于MySQL，下面来看看事务怎么使用：

// 开启一个会话
var session = db.getMongo().startSession({readPreference:{mode: "primary"}});
// 开启事务：指定读模式为快照读，写模式为半同步，即写入半数以上节点后再返回成功
session.startTransaction({readConcern: {level:"snapshot"}, writeConcern:{w: "majority"}});
// 获取要操作的集合对象
var trx_coll = session.getDatabase("库名").getCollection("集合名");

// 要在事务里执行的CRUD操作
......

// 回滚事务命令
session.abortTransaction();
// 提交事务命令
session.commitTransaction();
// 关闭会话命令
session.endSession();

大家一眼看下来，会发现使用起来非常麻烦，首先需要先拿到一个会话，接着开启事务时，还要指定一堆参数，回滚/提交事务的命令也不一样……，为此，如若之前没接触过的小伙伴，看着或许会很别扭。

这里重点解释一下开启事务的startTransaction()方法的参数，以及可选项，如下：

readConcern：指定事务的读取模式
- level：指定一致性级别
  - local：读取最近的数据，可能包含未提交的事务更改；
  - available：读取已提交的数据，可能包含尚未持久化的事务更改；
  - snapshot：读取事务开始时的一致快照，不包含未提交的事务更改；
writeConcern：指定事务的写入模式
- w：指定写操作的确认级别（同步模式）
  - [number]：写操作在写入指定数量的节点后，返回写入成功；
  - majority：写操作在写入大多数节点（半数以上）后，返回写入成功；
  - tagSetName：写操作在写入指定标签的节点后，返回写入成功；
- j：写入是否应被持久化到磁盘；
- wtimeout：指定写入确认的超时时间；
readPreference：定义读操作的节点优先级和模式
- mode：指定读取模式
  - primary：只从主节点读取数据；
  - secondary：只在从节点上读取数据；
  - primaryPreferred：优先从主节点读取，主节点不可用，转到从节点读取；
  - secondaryPreferred：优先在从节点读取，从节点不可用，转到主节点读取；
  - nearest：从可用节点中选择最近的节点进行读取；
- tagSets：在带有指定的标签的节点上执行读取操作

OK，对于MongoDB的事务机制，了解上述命令即可，毕竟MongoDB本身就不适用于强事务的场景，原因如下：

①MongoDB的事务必须在60s内完成，超时将自动取消（因为要考虑分布式环境）；
②涉及到事务的分片集群中，不能有仲裁节点（后面会解释仲裁节点）；
③事务会影响集群数据同步效率、节点数据迁移效率；
④多文档事务的所有操作，必须在主节点上完成，包括读操作；

综上所述，就算MongoDB支持事务，可实际使用起来也会有诸多限制，因此在不必要的情况下，不建议使用其事务机制。

接着再来说说MongoDB的锁机制，由于其天生的分布式特性，所以内部的锁机制尤为复杂，MySQL中有的锁概念，MongoDB中几乎都有，为此，详细、深入的内容可参考：MongoDB锁机制，这里只简单列出手动操作锁的命令，如下：

# 获取锁
db.collection.fsyncLock();
# 释放锁
db.collection.fsyncUnlock();

三、MongoDB索引机制

任何数据库都有索引这一核心功能，MongoDB自然不例外，而且MongoDB在索引方面特别完善，毕竟作为数据库领域的后起之秀，它集百家之长，将“借鉴”这一思想发挥到了极致，先来看看MongoDB索引的概念词：

单列索引、组合索引、唯一索引、全文索引、哈希索引、空间（地理位置）索引、稀疏索引、TTL索引……

怎么样？相信看过MySQL索引这篇文章的小伙伴一定眼熟，其中的索引名词和MySQL十分相似，接下来咱们挨个接触一下，当然，这里也先给出官方文档地址：MongoDB索引机制。

PS：早版本的MongoDB中，索引底层默认使用B-Tree结构，而4.x版本后，MongoDB推出了V2版索引，默认使用变种B+Tree来作为索引的数据结构（和MySQL索引的数据结构相同）。

3.1、初识MongoDB索引

在之前提到过，MongoDB会为每个集合生成一个默认的_id字段，该字段在每个文档中必须存在，可以手动赋值，如果不赋值则会默认生成一个ObjectId，该字段则是集合的主键，MongoDB会基于该字段创建一个默认的主键索引，后续基于_id字段查询数据时，会走索引来提升查询效率。

但当咱们基于其他字段查询时，由于未使用_id作为条件，这会导致find语句走全表查询，即从第一条数据开始，遍历完整个集合，从而检索到目标数据。当集合中的数据量，达到百万、千万、甚至更高时，意味着效率会直线下滑，在这种情况下，必须得由我们手动为频繁作为查询条件的字段建立索引。

这里咱们先来说说索引的分类，同MySQL一样，站在不同维度上来说，可以衍生出不同的分类。

从字段数量的维度划分：

单列索引：基于一个字段建立的索引；
组合索引：也叫复合索引、多列索引、联合索引，是由多个字段组成的索引；
多键索引：和上面的不同，如果索引字段为数组类型，MongoDB会专门为每个元素生成索引条目；
部分索引：使用一个或多个字段的前N个字节创建出的索引；

从排序维度上划分：

升序索引：一或多个字段组成的索引，排序方式完全为升序（从小到大）；
降序索引：一或多个字段组成的索引，排序方式完全为降序（从大到小）；
多序索引：多个字段组成的索引，但其中一部分字段为升序，一部分字段为降序；

从功能维度划分：

主键索引：MongoDB中默认为_id字段且不能更改，用于维护聚簇索引树；
普通索引：一或多个字段组成的索引，没有任何特殊性，只为提升检索效率；
唯一索引：一或多个字段组成的索引，值不能重复，且只允许一个文档不插入索引字段；
全文索引：一或多个字段组成的索引，集合内只能有一个，可以基于索引字段进行全文检索；
空间索引：基于地理空间数据字段创建的索引，支持平面几何的2D索引和球形几何的2D sphere索引；

从索引性质维度划分：

稀疏索引：结合唯一索引使用，允许一个唯一索引字段，出现多个null值；
TTL索引：类似于Redis的过期时间，为一个字段创建TTL索引后，超时会自动删除整个文档；
隐藏索引：在不删除索引的情况下，把索引隐藏起来，语句执行时不再走索引，相当于关闭索引；
通配符索引：给内嵌文档、且会发生动态变化的字段创建的索引；

从存储方式维度划分：

聚簇索引：索引数据和文档数据存储在一起的索引；
非聚簇索引：索引数据和文档数据分开存储的索引；

从数据结构维度划分：

B+树索引：索引底层采用B+Tree结构存储；
哈希索引：索引底层采用Hash结构存储；

显而易见，这里又出现了一堆索引相关的名词，不过好在其中大部分概念，和MySQL索引的概念相同，下面展开聊聊。

3.2、MongoDB索引详解

先来看看MongoDB中创建索引的命令，如下：

db.collection.createIndex(<key and index type specification>, <options>);

前面提到的所有索引，都是通过这一个方法创建，不同类型的索引，通过里面的参数和选项来区分，下面说明一下参数和可选项。

第一个参数主要是传字段，以及索引类型，这里可以传一或多个字段，用于表示单列/复合索引。

第二个参数表示可选项，如下：

background：是否以后台形式创建索引，因为创建索引会导致其他操作阻塞；
unique：是否创建成唯一索引；
name：指定索引的名称；
sparse：是否对集合中不存在的索引字段的文档不启用索引；
expireAfterSeconds：指定存活时间，超时后会自动删除文档；
v：指定索引的版本号；
weights：指定索引的权重值，权值范围是1~99999，当一条语句命中多个索引时，会根据该值来选择；

接着还是以之前的xiong_mao集合为例，来阐述索引相关内容，数据如下：

db.xiong_mao.insert([
    {_id:1, name:"肥肥", age:3, hobby:"竹子", color:"黑白色"},
    {_id:2, name:"花花", color:"黑白色"},
    {_id:4, name:"黑熊", age:3, food:{name:"黄金竹", grade:"S"}},
    {_id:5, name:"白熊", age:4, food:{name:"翠绿竹", grade:"B"}},
    {_id:6, name:"棕熊", age:3, food:{name:"明月竹", grade:"A"}},
    {_id:7, name:"红熊", age:2, food:{name:"白玉竹", grade:"S"}},
    {_id:8, name:"粉熊", age:6, food:{name:"翡翠竹", grade:"A"}},
    {_id:9, name:"紫熊", age:3, food:{name:"烈日竹", grade:"S"}},
    {_id:10, name:"金熊", age:6, food:{name:"黄金竹", grade:"S"}}
]);

3.2.1、单列索引

db.xiong_mao.createIndex({name: -1}, {name: "idx_name"});

这代表着基于name字段，创建一个名为idx_name的单列普通索引，-1代表降序，不过对于单字段的索引而言，排序方式并不重要，因为索引底层默认是B+Tree，每个文档之间会有双向指针，为此，MongoDB基于单字段索引查询时，既可以向前、也可以向后查找数据，示意图如下：

创建完成后，可以通过db.xiong_mao.getIndexes()命令查询索引，如下：

[
  {
   
   v: 2, key: {
   
    _id: 1 }, name: '_id_'},
  {
   
   v: 2, key: {
   
    name: -1 }, name: 'idx_name'}
]

这里可以看到，MongoDB默认给_id字段创建的索引，第二个则是咱们手动创建的索引，索引的版本为2（如果不指定索引名，会按“字段名+下划线+排序方式”规则默认生成）。

再来看一种情况，例如现在将集合中的爱好字段，变为一个数组：

{_id:1, name:"肥肥", age:3, hobby:["竹子", "睡觉"], color:"黑白色"}

现在给hobby字段创建一个索引，这时叫啥索引？多键索引！因为这里是基于单个数组类型的字段在建立索引，所以MongoDB会为数组中的每个元素，都生成索引的条目（即索引键），由于一个文档的数组字段，拥有多个元素，因此会创建多个索引键，这也是“多键索引”的名字由来。

3.2.2、复合索引

复合索引是指基于多个字段创建的索引，例如：

db.xiong_mao.createIndex({name:-1, age:1}, {name:"idx_name_age"});

这里基于name、age字段两个字段，创建了一个复合索引，其中指定了按name降序、age升序，这个排序就有意义了，MongoDB生成索引键时，会按照指定的顺序，来将索引键插入到树中。

说明：索引键=索引字段的值，比如现在一个文档的name=zhuzi、age=3，索引键为zhuzi3。
注意：由于这里的顺序是{name:-1, age:1}，所以当排序查询时，支持sort({name:-1,age:1})、sort({name:1,age:-1})，因为这两个顺序和树的组成顺序要么完全相同、相反，而当执行sort({name:-1,age:-1})、sort({name:1,age:1})排序查询时，将不会使用索引，因为这时和树的顺序冲突。

这里咱们用explain命令浅浅分析一下：

db.xiong_mao.find({}).sort({name:1,age:1}).explain("executionStats");
db.xiong_mao.find({}).sort({name:-1,age:1}).explain("executionStats");

执行结果信息比较多，这里只贴出关键信息，如下：

从图中能明显看出，第一条与索引顺序冲突的语句，走的是COLLSCAN全集合扫描；而第二条复合索引顺序的语句，走的是IXSCAN索引扫描，使用了name_-1_age_1这个索引检索到了数据，因此这点在使用复合索引时一定要注意！

同时，因为刚刚又给name、age字段建立了一个复合索引，所以最开始建立name单列索引，属于冗余的重复索引，这时可以通过dropIndex命令删除掉，如下：

// 自定义名称创建的索引，需要传入名称删除
db.xiong_mao.dropIndex("name_-1");
// 使用默认名称创建的索引，可以直接传入创建时的字段+顺序
db.xiong_mao.dropIndex({name:-1});
// 这个方法可以删除一个集合的所有索引（除开默认的_id索引外）
db.xiong_mao.dropIndexes();

顺便这里也提一句，如果索引在创建时未指定名称，中途是不可以重命名的，只能先删再建时重新命名。

3.2.3、唯一索引

唯一索引相信大家都熟悉，它必须创建在不会出现重复值的字段上，基于唯一索引查找数据时，找到第一个满足条件的数据，就会立马停止匹配，毕竟该字段的值在集合中是唯一的，创建的方式如下：

db.xiong_mao.createIndex({name:1}, {unique: true});

只需要将unique设置为true即可，现在再尝试向集合中插入一条name重复的文档：

db.xiong_mao.insertOne({name: "肥肥"});
[Error] index 0: 11000 - E11000 duplicate key error collection: 
    zhuzi.xiong_mao index: name_1 dup key: { name: "肥肥" }

这时就会因为name值违反唯一约束而报错。OK，再来看一个特殊情况：

db.xiong_mao.insertOne({_id:66, age: 1});
db.xiong_mao.insertOne({_id:77, age: 2});

这时大家查询一下该集合，会发现_id=66这条数据会插入进去，而77这条数据会报错，这是为什么？

因为MongoDB中，可以向集合中动态插入不同的字段，上面两条语句都没有指定name字段，这时MongoDB默认会将这两条语句的name字段置空，而name=null的情况，也会被当作一个索引键，插入到索引树中。由于name字段建立了唯一索引，因此空值情况也只能出现一次。

那这个问题能不能解决呢？当然可以，这里需要用到稀疏索引，“稀疏”是索引的一种特性，如下：

// 先删除索引
db.xiong_mao.dropIndex("name_1");
// 再重新建立一次，并将sparse选项置为true
db.xiong_mao.createIndex({name:1}, {unique:true, sparse:true});

这时再执行前面的两条语句，就能同时插入了！后续可以通过null值，来查询没有唯一索引字段的文档：

db.xiong_mao.find({name:null});

3.2.4、部分索引

部分索引即使用字段的一部分开创建索引，但必须要结合partialFilterExpression选项来实现，如下：

db.xiong_mao.createIndex(
  // 给hobby字段创建索引
  {hobby:1},
  {partialFilterExpression: {
      hobby: {
        // 只为存在hobby字段的文档创建索引
        $exists: true,
        // 通过$substr操作符，截取前1个字节作为索引键
        $expr: {$eq: [{$substr:["$hobby", 0, 1] },"prefix"]}
      }
    }}
);

其实这就类似于MySQL中的前缀索引，不过MongoDB的中的部分索引功能更强大，还可以只为集合中的一部分文档创建索引，例如：

db.xiong_mao.createIndex(
   {age: -1},
   // 只为集合中年龄大于2岁的文档创建索引
   {partialFilterExpression: {age: {$gt: 2}}}
);

为此，这里纠正一下：在最开始给出的索引分类概念中，将部分索引解释成了前缀索引的概念，实则不然，其实还可以为集合里的一部分数据创建索引！

3.2.5、TTL索引

TTL索引这个类型比较有趣，可以基于它实现过期自动删除的效果，主要依靠expireAfterSeconds选项来创建，不过只能在Date、ISODate类型的字段上，建立TTL索引，如下：

db.test_ttl.insertMany([
    // new Date()表示插入当前时间
    {_id:1, time:new Date()},
    {_id:2, time:new Date()},
    {_id:3, time:new Date()},
    {_id:4, time:new Date()},
    {_id:5, notes:"这条数据用于观察TTL删除特性"}
]);
db.test_ttl.find();
db.test_ttl.createIndex({time: 1}, {expireAfterSeconds: 10});

上面新建了一个ttl_test集合，并向其中插入了5条数据，接着对time字段创建了一个TTL索引，给定的过期时间为10s，这里咱们稍等12s左右再去查询：

db.test_ttl.find();
[{_id: 5, notes: '这条数据用于观察TTL删除特性'}]

此时会发现，只剩下了_id=5这条没有time字段的数据，从这点就可以观察出TTL索引的特性，不过大家在使用时需要注意：TTL索引只能建在单字段上，不支持建立TTL复合索引；同时，TTL索引只能建立在类型为Date、ISODate的字段上，在其他类型的字段上建立TTL索引，文档永远不会过期。

这里说明一下，为什么TTL索引必须基于Date类型的字段创建呢？因为MongoDB会使用该字段的值，作为计算的起始时间，如果在一个Date数组类型的字段上建立TTL索引，MongoDB会使用其中最早的时间来计算过期时间。

3.2.6、全文索引

在MySQL中想实现模糊查询，一般会采用like关键字；而在MongoDB中想实现模糊查询，官方并没有提供相关方法与操作符，只能通过自己写正则的形式，实现模糊查找的功能，那有没有更好的方法呢？答案是有，为相应字段创建全文索引即可。

全文索引在之前讲MySQL索引时也聊到过，在数据量不大不小（几百万左右）、查询又不是特别复杂的情况下，直接上ElasticSearch、Solr等中间件，显得有点大材小用，此时全文索引就是这类搜索引擎的平替。不过相较于MySQL，MongoDB提供的全文索引，功能方面会更加强大。

创建的语法如下：

db.xiong_mao.createIndex({name: "text"}, {name:"ft_idx_name"});

这里对name字段建立了一个全文索引，和创建普通索引的区别在于：在字段后面加了一个text。

不过要注意，MongoDB全文索引停用词、词干和词器的规则，默认为英语，想要更改，这里涉及到创建索引时的两个可选项：

default_language：指定全文索引停用词、词干和词器的规则，默认为english；
language_override：指定全文索引语言覆盖的范围，默认为language；

不过注意，不管任何技术栈的全文索引，对中文的支持都不太友好，分词方面总会有点不完善，所以MongoDB很鸡贼，全文索引直接不支持中文，当你试图通过default_language:"chinese"去将语言改为中文时，会直接给你返回报错~

当然，正是由于MongoDB的全文索引不支持中文，因此就算你给一个字符串字段，建立了全文索引后，也无法实现全文搜索，如下：

db.xiong_mao.find({$text: {$search: "熊"}});

这段语句的含义是：通过全文索引搜索含“熊”这个关键字的数据，在咱们前面给出的集合数据中，name包含“熊”的数据有好几条，但这条语句执行之后的结果为null。想要解决这个问题，必须要手动安装第三方的中文分词插件，如mmseg、jieba等。

当然，如果你字段中的值是英文，这自然是支持的，例如：

// 先向集合中插入三个name为英文的文档
db.xiong_mao.insertMany([
    {_id:21, name:"jack bear", age: 1},
    {_id:22, name:"coly bear", age: 2},
    {_id:23, name:"alan bear", age: 3}
]);

// 再使用英文作为关键字进行全文搜索（多个关键字用空格分隔）
db.xiong_mao.find({$text: {$search: "jack coly"}});
// =============结果=============
[
  { _id: 22, name: 'coly bear', age: 2 },
  { _id: 21, name: 'jack bear', age: 1 }
]

结果很明显，全文索引对英文完全支持，不过关于全文索引更多的搜索方法，大家可自行查阅官方文档，或寻找相关资料，这里不再过多阐述。

3.2.7、空间索引

空间索引，这玩意儿很多人用不到，除非涉及到地图、出行类的业务，或者其他涉及到坐标的场景，毕竟这时才会存储经纬度，MongoDB的空间索引，必须建立在类型为Point的字段上，总共有三种空间索引：

2D：适用于平面上的二维几何数据；
2Dsphere：适用于球面上的二维几何数据；
geoHaystack：2D索引的升级版，适用于平面的特定坐标数据（查询性能更高）；

这里来演示一下，先创建一个名为“熊猫馆”的集合，并插入几条坐标数据：

db.panda_house.insertMany([
    {_id:1, house_name:"熊猫高级会所", location:{type: "Point", coordinates:[-66.66, 22.22]}},
    {_id:2, house_name:"竹子高级会所", location:{type: "Point", coordinates:[-88.88, 55.55]}},
    {_id:3, house_name:"竹子爱熊猫会所", location:{type: "Point", coordinates:[-77.88, 11.22]}}
]);

接着我们为其location字段，创建一个2dsphere空间索引：

db.panda_house.createIndex({location:"2dsphere"});

接着可以使用坐标来进行查询，例如查询某个坐标附近五公里内的熊猫馆：

db.panda_house.find(
    // 基于location字段进行查询
    {location: {
        // $near用来实现坐标附近的数据检索，返回结果会按距离排序
        $near: {
            // $geometry操作符用于指定Geo对象（地理空间对象）
            $geometry: {
                type:"Point", coordinates: [-66.66, 22.21]}, 
                // $maxDistance限制了最大搜索距离为5000m（五公里）
                $maxDistance: 5000
        }}
});

上述语句执行后，最终会把“熊猫高级会所”这条数据搜索出来，是不是和你点外卖时的搜索场景很像？

3.2.8、哈希索引

哈希索引是等值查询时最快的索引，在之前MySQL篇章也提及过它，只不过MySQL-InnoDB引擎中，不支持手动创建哈希索引，只能由InnoDB运行时自动生成，即自适应哈希索引技术。反观MongoDB中，默认使用的索引结构为B+Tree，但它也支持手动创建哈希结构的索引，语法如下：

db.xiong_mao.createIndex({name:'hashed'});

我们只需要在创建索引时，在字段后显式指明hashed即可，这样在做等值查询时，就会自动使用哈希索引。

不过注意，哈希索引只支持等值查询的场景，如果一个字段还需要参与范围查询、排序等场景，那么并不建议在该字段上建立哈希索引。同时，创建哈希索引的字段，其值必须具备分散性，如年龄、性别这类字段，显然并不适合，大量重复值会导致哈希冲突十分严重，像手机号、身份证号这类属性的字段，就特别适合建立哈希索引。

3.2.9、通配符索引

在前面提到过“内嵌文档”这个概念，这是指将另一个文档，以字段值的形式嵌入到一个文档中。

结合MongoDB可以动态插入各种字段的特性，每个内嵌文档的字段，也可以灵活变化，例如前面给出的数据：

{_id:4, name:"黑熊", age:3, food:{name:"黄金竹", grade:"S"}},
{_id:5, name:"白熊", age:4, food:{name:"翠绿竹", grade:"B"}},
......

这些数据中都内嵌了一个food文档，虽然现在插入的都是固定的name、grade字段，但我们可以随时插入新的字段，例如：

db.xiong_mao.insertOne({
    _id:99, name:"星熊", age: 1,
    food: {name:"星光竹", grade:"S", quality_inspector: ["竹大","竹二"]}
});

这时新插入的文档，其food字段又多了一个quality_inspector质检员的属性，对于这种动态变化的字段，可不可以建立索引呢？答案是可以，MongoDB4.2中引入了“通配符索引”来支持对未知或任意字段的查询操作，创建的语法如下：

db.xiong_mao.createIndex({"food.$**": 1});

这时再通过food字段来进行查询，看看explain执行计划：

db.xiong_mao.find({"food.grade":"S"}).explain();

执行计划中很明显，通过food字段作为查询条件时，用到了刚刚创建的通配符索引。

最后，如果你想观察一个索引到底有没有效果，可以对比有索引、没索引时的查询耗时，但咱们需要把索引删掉吗？这是不需要的，MongoDB支持隐藏索引，可以把一个已有索引“藏”起来，相关命令如下：

// 创建隐藏索引
db.<集合名>.createIndex({<字段名>:<排序方式>}, {hidden: true});

// 隐藏已有索引
db.<集合名>.hideIndex({<字段名>:<排序方式>});
db.<集合名>.hideIndex("索引名称");

// 取消隐藏索引
db.<集合名>.unhideIndex({<字段名>:<排序方式>});
db.<集合名>.unhideIndex("索引名称");

OK，MongoDB基于索引查询时，同样也支持索引覆盖，也就是需要返回的结果字段，在索引字段中有时，会直接返回索引键的值，并不会再次回表查询整个文档。

3.3、explain执行计划

在之前的《SQL优化篇》中，曾详细说到过MySQL的explain工具，通过该命令，能有效帮咱们分析语句的执行情况，而MongoDB同样也提供了这个命令，在上面的索引阶段，也简单使用过，命令格式如下：

db.<collection>.find().explain(<verbose>);

explain方法同样有三个模式可选，这里简单列出来：

queryPlanner：返回执行计划的详细信息，包括查询计划、集合信息、查询条件、最佳计划、查询方式、服务信息等（默认模式）；
exectionStats：列出最佳执行计划的执行情况和被拒绝的计划等信息（即语句最终执行的方案）；
allPlansExecution：选择并执行最佳执行计划，同时输出其他所有执行计划的信息；

一般排查find()查询缓慢问题时，可以先指定第二个模式，查看最佳执行计划的信息；如果怀疑MongoDB没选择好索引，则可以再指定第三个模式，查看其他执行计划，如果的确是因为走错了索引，这时你可以通过hint强制指定要使用的索引，如下：

db.集合名.find(查询条件).hint(索引名);

OK，接着来了解一下explain命令输出的信息含义，大家可以自行去mongosh里执行一下explain命令，会发现它输出了特别多的信息，咱们主要关注stage这个值，这是最重要的字段，就类似于MySQL-explain的type字段，代表着本次语句的查询类型，该字段可能会出现以下值：

COLLSCAN：扫描整个集合进行查询；
IXSCAN：通过索引进行查询；
COUNT_SCAN：使用索引在进行count操作；
COUNTSCAN：没使用索引在进行count操作；
FETCH：根据索引键去磁盘拿具体的数据；
SORT：执行了sort排序查询；
LIMIT：使用了limit限制返回行数；
SKIP：使用了skip跳过了某些数据；
IDHACK：通过_id主键查询数据；
SHARD_MERGE：从多个分片中查询、合并数据；
SHARDING_FILTER：通过mongos对分片集群执行查询操作；
SUBPLA：未使用索引的$or查询；
TEXT：使用全文索引进行查询；
PROJECTION：本次查询指定了返回的结果集字段（投影查询）；

这里咱们只需要带SCAN后缀的，因为其他都属于命令执行的“阶段”，并不属于具体的类型，explain会将一条语句执行的每个阶段，都详细列出来，每个阶段都会有stage字段，我们要做的，就是确保每个阶段都能用上索引即可，如果某一阶段出现COLLSCAN，在数据量较大的情况下，都有可能导致查询缓慢。

其次，咱们需要关心keysExamined、docsExamined两个字段的值（exectionStats模式下才能看到），前者代表扫描的索引键数量，后者代表扫描的文档数量，前者越大，代表索引字段值的离散性太差，后者的值越大，一般代表着没建立索引。

OK，这里暂时了解这么多，关于explain其余的输出信息，很多跟集群有关系，为此，等后续把MongoDB集群过了之后，有机会再详细讲述~

四、MongoDB安全与权限管理

通常为了保证数据安全性，Redis、MySQL、MQ、ES……，通常都会配置账号/密码，一来可以提高安全等级，二来还可以针对不同库、操作设置权限，极大程度上降低了数据的安全风险。同样，在MongoDB中也支持创建账号、密码，以及分配权限，并且还支持角色的概念，可以先为角色分配权限，再为用户绑定角色，从而节省大量重复的权限分配工作。

同时，MongoDB中还内置了大量常用角色，方便于咱们快速分配权限，不过并没有默认的账号，所以想要启用MongoDB的访问控制，还需要先创建一个账号：

// 切换到admin数据库
use admin;
// 创建一个用户，并赋予root角色（root角色只能分配给admin库）
db.createUser({"user":"zhuzi", "pwd":"123456", "roles":["root"]});
// 退出mongosh客户端
quit;

接着再关闭MongoDB服务，重新启动时开启访问控制，必须使用账号密码连接才允许操作：

[root@~]# /soft/mongodb/bin/mongod -shutdown -f /soft/mongodb/conf/standalone/mongodb.conf
[root@~]# /soft/mongodb/bin/mongod -auth -f /soft/mongodb/conf/standalone/mongodb.conf
[root@~]# /soft/mongodb/mongosh/bin/mongosh 192.168.229.135:27017

或者这里也可以直接修改配置文件：

[root@~]# vi /soft/mongodb/conf/standalone/mongodb.conf

# 在配置文件结尾加上这两行
security:
    authorization: enabled

然后通过不带-auth的命令启动，效果同样是相同的。

接着先切换到咱们前面创建的zhuzi库，查询一下xiong_mao集合试试看：

use zhuzi;
db.xiong_mao.find({_id:1});
MongoServerError: command find requires authentication

此时就会看到对应报错，提示目前未授权，所以无法执行命令，因此这里需要登录一下，不过登录必须要切换到admin库下才可以，否则会提示认证失败：

db.auth("zhuzi", "123456");
{ ok: 1 }

use zhuzi;
db.xiong_mao.find({_id:1});
[ { _id: 1, name: '肥肥', age: 3, hobby: '竹子', color: '黑白色' } ]

认证成功后，再次切回zhuzi库查询，此时会发现数据依旧可以查询出来。

当然，如果不想每次连接时都切换到admin库下登录，然后再切换回来，此时可以在zhuzi库下再创建一个用户，如下：

// 先切换到zhuzi库
use zhuzi;

// 再在zhuzi库下创建一个zhuzi用户，并分配dbOwner角色
db.createUser({"user":"zhuzi", "pwd":"123456", "roles":[{"role":"dbOwner", "db":"zhuzi"}]});

// 退出连接
quit;

然后可以再次连接MongoDB服务，这时直接切换到zhuzi库下登录后，也照样可以读写数据，而关于上述命令中分配的dbOwner角色是什么意思呢？后面会说明。

4.1、MongoDB内置角色

前面大致了解了一下如何启用访问控制后，接着来看看MongoDB中的内置角色，毕竟前面只使用了root角色，可以通过下述命令来查询MongoDB所有内置角色：

use admin;
db.runCommand({rolesInfo: 1, showBuiltinRoles: true});

返回结果较长，这里就不贴了，大家可以自己执行一下，这里归类一下：

root：超级管理员权限，可以执行任何操作；
read：只读用户，不允许对数据库执行写入操作；
readWrite：读写用户，允许对数据执行读写操作；
dbAdmin：数据库管理员（如创建和删除数据库），不允许读写数据；
userAdmin：用户管理员（如创建和删除用户），不允许读写数据；
dbOwner：同时拥有dbAdmin、userAdmin两个角色的权限，且允许读写数据；
backup：具有备份和恢复权限，不允许读写数据；
restore：只具有数据恢复权限，不允许读写数据；
clusterAdmin：集群超级管理员，可以执行集群中任意操作，允许读写数据；
clusterManager：集群管理员，只可以管理集群节点、配置等；
clusterMonitor：集群监视员，允许监控集群的状态和性能，不允许读写数据；

上面是一些常用的角色，而对于其他使用频率较少的则不再列出，而这些内置角色，可以在创建用户的时候分配，一个用户同时可以绑定多个角色。但如果你想要的权限，内置角色并不提供，也可以自定义角色，下面来看看。

4.2、MongoDB自定义角色

先来看看自定义角色的语法：

use zhuzi;

db.createRole(
    {
    // 自定义角色的名称
    role:"zhuziRole",
    // 自定义角色拥有的权限集
    privileges: [
        {
           // 自定义角色可操作的资源 
           resource:
            {
                // 当前角色可操作zhuzi库
                db:"zhuzi",
                // 当前角色具体可操作的集合（多个传数组，所有写""）
                collection:""
            },
            // 当前角色拥有的权限
            actions: ["find", "update", "insert", "remove"]
        }
        ],
        // 当前角色是否继承其他角色，如果指定了其他角色，当前角色自动继承父亲的所有权限
        roles: []
    }
);

关于该命令中的具体含义，大家可以参考上面的注释，通过该方式，诸位可以灵活的创建出各种适用于业务的角色，最后再附上一些相关命令：

// 给指定角色增加权限
db.grantPrivilegesToRole(
    "角色名称",
    [{
        resource: {
          db: "库名",
          collection: ""
        }, 
        actions: ["权限1","……"]
    }]
);

// 回收指定角色的权限
db.revokePrivilegesFromRole(
    "角色名称",
    [{
        resource: {
          db: "库名",
          collection: ""
        }, 
        actions: ["权限1","……"]
    }]
);

// 删除角色（要先进入角色所在的库）
use zhuzi;
db.dropRole("角色名称");

// 查看当前库的所有角色
show roles;

// 查看当前库中所有用户
show users;

OK，掌握上述这些命令完全能满足日常需求了，至于其他更多的，则可以参考官网或自行查阅资料。

五、MongoDB入门篇总结

到这里，MongoDB入门篇内容就结束了，原本打算一篇写完，结果发现这篇就有好几万字了，由于平台字数限制，所以拆成了三篇来写，每一篇分别对应不同的学习阶段，上篇写入门、中篇写进阶、下篇写Java应用（如果是其他语言的读者，需要自行寻找对应客户端的应用文）。

当然，虽然这篇字数最多，但大多数在讲API应用，因此阅读难度并不算大，更多考验的是耐心，如若你有耐心阅读至此，那么恭喜你！又掌握了一项新的技术栈~

MongoDB保姆级指南(上)：七万字从零到进阶，助你掌握又一款强大的NoSQL！

引言

一、MongoDB快速入门

1.1、MongoDB环境搭建

1.2、MongoDB增删改查

1.3、库与集合的命令

二、MongoDB渐悉

2.1、新增操作

2.2、删除操作

2.3、修改操作

2.4、查询操作

2.4.1、基本查询语句

2.4.2、聚合管道查询

2.4.3、嵌套文档的增删改查

2.4.4、多个集合关联查询

2.5、数据类型

2.6、事务与锁机制

三、MongoDB索引机制

3.1、初识MongoDB索引

3.2、MongoDB索引详解

3.2.1、单列索引

3.2.2、复合索引

3.2.3、唯一索引

3.2.4、部分索引

3.2.5、TTL索引

3.2.6、全文索引

3.2.7、空间索引

3.2.8、哈希索引

3.2.9、通配符索引

3.3、explain执行计划

四、MongoDB安全与权限管理

4.1、MongoDB内置角色

4.2、MongoDB自定义角色

五、MongoDB入门篇总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

MongoDB保姆级指南(上)：七万字从零到进阶，助你掌握又一款强大的NoSQL！

引言

一、MongoDB快速入门

1.1、MongoDB环境搭建

1.2、MongoDB增删改查

1.3、库与集合的命令

二、MongoDB渐悉

2.1、新增操作

2.2、删除操作

2.3、修改操作

2.4、查询操作

2.4.1、基本查询语句

2.4.2、聚合管道查询

2.4.3、嵌套文档的增删改查

2.4.4、多个集合关联查询

2.5、数据类型

2.6、事务与锁机制

三、MongoDB索引机制

3.1、初识MongoDB索引

3.2、MongoDB索引详解

3.2.1、单列索引

3.2.2、复合索引

3.2.3、唯一索引

3.2.4、部分索引

3.2.5、TTL索引

3.2.6、全文索引

3.2.7、空间索引

3.2.8、哈希索引

3.2.9、通配符索引

3.3、explain执行计划

四、MongoDB安全与权限管理

4.1、MongoDB内置角色

4.2、MongoDB自定义角色

五、MongoDB入门篇总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像