高效NoSQL数据库利器：Mongodb完整教程_mongo 脚本执行

1、Mongodb介绍

1.1、什么是Mongodb

MongoDB是一个文档数据库（以 JSON 为数据模型），由C++语言编写，旨在为WEB应用提供可扩展的 高性能数据存储解决方案。

文档来自于“JSON Document”，并非我们一般理解的 PDF，WORD 文档。

MongoDB是非关系数据库当中功能最丰富，最像 关系数据库的。它支持的数据结构非常松散，数据格式是BSON，一种类似JSON的二进制形式的存储格 式，简称Binary JSON ，和JSON一样支持内嵌的文档对象和数组对象，因此可以存储比较复杂的数据类 型。MongoDB最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几 乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。原则上 Oracle 和 MySQL 能做的事情，MongoDB 都能做（包括 ACID 事务）。

MongoDB在数据库总排名第5，仅次于Oracle、MySQL等RDBMS，在NoSQL数据库排名首位。从诞生 以来，其项目应用广度、社区活跃指数持续上升。

MongoDB概念与关系型数据库（RDBMS）非常类似：

• 数据库（database）：最外层的概念，可以理解为逻辑上的名称空间，一个数据库包含多个不同名 称的集合。
• 集合（collection）：相当于SQL中的表，一个集合可以存放多个不同的文档。
• 文档（document）：一个文档相当于数据表中的一行，由多个不同的字段组成。
• 字段（field）：文档中的一个属性，等同于列（column）。
• 索引（index）：独立的检索式数据结构，与SQL概念一致。
• id：每个文档中都拥有一个唯一的id字段，相当于SQL中的主键（primary key）。
• 视图（view）：可以看作一种虚拟的（非真实存在的）集合，与SQL中的视图类似。从MongoDB 3.4版本开始提供了视图功能，其通过聚合管道技术实现。
• 聚合操作（$lookup）：MongoDB用于实现“类似”表连接（tablejoin）的聚合操作符。

尽管这些概念大多与SQL标准定义类似，但MongoDB与传统RDBMS仍然存在不少差异，包括：

• 半结构化，在一个集合中，文档所拥有的字段并不需要是相同的，而且也不需要对所用的字段进行 声明。因此，MongoDB具有很明显的半结构化特点。除了松散的表结构，文档还可以支持多级的 嵌套、数组等灵活的数据类型，非常契合面向对象的编程模型。
• 弱关系，MongoDB没有外键的约束，也没有非常强大的表连接能力。类似的功能需要使用聚合管 道技术来弥补。

1.2、MongoDB的优势

MongoDB基于灵活的JSON文档模型，非常适合敏捷式的快速开发。与此同时，其与生俱来的高可用、 高水平扩展能力使得它在处理海量、高并发的数据应用时颇具优势。

• 横向扩展力，轻松支持TB-PB数量级

• JSON 结构和对象模型接近，开发代码量低

• JSON的动态模型意味着更容易响应新的业务需求

• 复制集提供99.999%高可用

• 分片架构支持海量数据和无缝扩容

2、MongoDB快速开始

2.1、linux安装MongoDB

下载MongoDB Community Server

下载地址: https://www.mongodb.com/try/download/community

重命名

mv mongodb-linux-x86_64-rhel70-4.4.15 mongodb
1

添加环境变量

修改/etc/profile，添加环境变量,方便执行MongoDB命令

export MONGODB_HOME=/qijingjing/resource/mongodb
PATH=$PATH:$MONGODB_HOME/bin
1
2

使环境变量立即生效

source /etc/profile
1

2.2、启动MongoDBServer

# 创建一些存放数据、日志、配置的文件夹
mkdir -p data log conf
# 创建一个日志文件
touch log/mongodb.log
# 进行启动
bin/mongod --port=27017 --dbpath=data --logpath=log/mongodb.log --fork
1
2
3
4
5
6

名词解释

• –dbpath :指定数据文件存放目录
• –logpath :指定日志文件，注意是指定文件不是目录
• –logappend :使用追加的方式记录日志
• –port:指定端口，默认为27017
• –bind_ip:默认只监听localhost网卡
• –fork: 后台启动
• –auth: 开启认证模式

利用配置文件启动服务

编辑mongodb/conf/mongo.conf文件，内容如下

systemLog:
  destination: file
  path: /qijingjing/resource/mongodb/log/mongod.log # 日志文件的全路径
  logAppend: true
storage:
  dbPath: /qijingjing/resource/mongodb/data # 存放数据文件夹的的全路径
  engine: wiredTiger #存储引擎
  journal: #是否启用journal日志
    enabled: true
net:
  bindIp: 0.0.0.0 #开启可以使外网访问
  port: 27017 # 端口号
processManagement:
  fork: true
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意一定要yaml格式

启动mongod(没有关闭要先关闭mongod，然后再启动)

mongod -f conf/mongo.conf
1

关闭MongoDB服务

方式一：

mongod --port=27017 --dbpath=data --shutdown
1

方式二：

执行mongo命令进入shell界面

use admin;
db.shutdownServer();
1
2

2.3、MongoDB shell的使用

mongo是MongoDB的交互式JavaScript Shell界面，它为系统管理员提供了强大的界面，并为开发人员 提供了直接测试数据库查询和操作的方法。

mongo --port=27017
1

–port：指定端口，默认为27017

–host: 连接的主机地址，默认为127.0.0.1

JavaScript支持

mongo shell是基于JavaScript语法的，MongoDB使用了SpiderMonkey作为其内部的JavaScript解释器 引擎，这是由Mozilla官方提供的JavaScript内核解释器，该解释器也被同样用于大名鼎鼎的Firefox浏览 器产品之中。SpiderMonkey对ECMA Script标准兼容性非常好，可以支持ECMA Script 6。可以通过下 面的命令检查JavaScript解释器的版本：

mongo shell 常用命令

2.3.1、数据库操作

#查看所有库
show dbs
# 切换到指定数据库，不存在则创建
use test
# 删除当前数据库
db.dropDatabase()
1
2
3
4
5
6

2.3.2、集合操作

#查看集合
show collections
#创建集合
db.createCollection("emp")
#删除集合
db.emp.drop()
1
2
3
4
5
6

创建集合语法

db.createCollection(name,options)
1

options参数

注意：当集合不存在时，向集合中插入文档也会创建集合

2.4、安全认证

2.4.1、创建管理员账号

# 设置管理员用户名密码需要切换到admin库
use admin
#创建管理员
db.createUser({user:"root",pwd:"root",roles:["root"]})
# 查看所有用户信息
show users
#删除用户
db.dropUser("root")
1
2
3
4
5
6
7
8

---

2.4.2、常用权限

用户认证，返回1表示认证成功

> use admin
switched to db admin
> db.auth("root","root")
1
1
2
3
4

2.4.3、创建应用数据库用户

use appdb
db.createUser({user:"123456",pwd:"123456",roles:["dbOwner"]})
1
2

默认情况下，MongoDB不会启用鉴权，以鉴权模式启动MongoDB

mongod -f conf/mongo.conf --auth
1

启用鉴权之后，连接MongoDB的相关操作都需要提供身份认证。

mongo -u 123456 -p 123456 --authenticationDatabase=appdb
1

3、MongoDB文档操作

3.1、插入文档

3.2版本之后新增了db.collection.insertOne()和db.collection.insertMany().

新增单个文档

• insertOne: 支持writeConcern

db.collection.insertOne(
   <document>,
   {
      writeConcern: <document>
   }
)
1
2
3
4
5
6

writeConcern 决定一个写操作落到多少个节点上才算成功。writeConcern 的取值包括： 0：发起写操作，不关心是否成功；

1~集群最大数据节点数：写操作需要被复制到指定节点数才算成功；

majority：写操作需要被复制到大多数节点上才算成功

• insert: 若插入的数据主键已经存在，则会抛 DuplicateKeyException 异常，提示主键重复，不保存当前数据

• save: 如果_id主键存在则更新数据，如果不存在就插入数据。

> db.emp.insert({name:"张三",age:12})
WriteResult({ "nInserted" : 1 })
> db.emp.save({name:"李四",age:3})
WriteResult({ "nInserted" : 1 })
> db.emp.insertOne({sex:1,age:2})
{
	"acknowledged" : true,
	"insertedId" : ObjectId("62c410ed65d7649befbb697a")
}
> db.emp.find()
{ "_id" : ObjectId("62c410ac65d7649befbb6978"), "name" : "张三", "age" : 12 }
{ "_id" : ObjectId("62c410b465d7649befbb6979"), "name" : "李四", "age" : 3 }
{ "_id" : ObjectId("62c410ed65d7649befbb697a"), "sex" : 1, "age" : 2 }
> 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

批量新增文档

• insertMany: 向指定集合中插入多条文档数据

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

writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求。

ordered：指定是否按顺序写入，默认 true，按顺序写入。

• insert和save也可以实现批量插入

> db.emp.insert([{x:5,y:7},{x:3,y:9}])
BulkWriteResult({
	"writeErrors" : [ ],
	"writeConcernErrors" : [ ],
	"nInserted" : 2,
	"nUpserted" : 0,
	"nMatched" : 0,
	"nModified" : 0,
	"nRemoved" : 0,
	"upserted" : [ ]
})
> db.emp.save([{x:50,y:70},{x:30,y:90}])
BulkWriteResult({
	"writeErrors" : [ ],
	"writeConcernErrors" : [ ],
	"nInserted" : 2,
	"nUpserted" : 0,
	"nMatched" : 0,
	"nModified" : 0,
	"nRemoved" : 0,
	"upserted" : [ ]
})
> db.emp.insertMany([{x:550,y:750},{x:350,y:950}])
{
	"acknowledged" : true,
	"insertedIds" : [
		ObjectId("62c4143565d7649befbb6980"),
		ObjectId("62c4143565d7649befbb6981")
	]
}
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

测试: 批量插入50条随机数据

编辑脚本book.js

var tags = ["nosql","mongodb","document","developer","popular"];
var types = ["technology","sociality","travel","novel","literature"];
var books=[];
for(var i=0;i<50;i++){
    var typeIdx = Math.floor(Math.random()*types.length);
    var tagIdx = Math.floor(Math.random()*tags.length);
    var favCount = Math.floor(Math.random()*100);
    var book = {
        title: "book-"+i,
        type: types[typeIdx],
        tag: tags[tagIdx],
		favCount: favCount,
		author: "xxx"+i
	};
	books.push(book)
}
db.books.insertMany(books);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

进入mongo shell ,执行

load("book.js")
1

读取：

db.books.find()

有分页，输入it进入下一页

3.2、查询文档

find查询集合中的若干文档。语法格式如下：

db.collection.find(query, projection)
1

• query: 可选，使用查询操作符指定查询条件
• projection：可选，使用投影操作符指定返回的键。查询时时返回文档中所有键值， 只需省略该参 数即可（默认省略）。投影时，id为1的时候，其他字段必须是1；id是0的时候，其他字段可以是 0；如果没有_id字段约束，多个其他字段必须同为0或同为1。

如果查询返回的条目数量较多，mongo shell则会自动实现分批显示。默认情况下每次只显示20条，可 以输入it命令读取下一批。

findOne查询集合中的第一个文档。语法格式如下：

db.collection.findOne(query, projection)
1

条件查询

#查询带有nosql标签的book文档：
db.books.find({tag:"nosql"})
#按照id查询单个book文档：
db.books.find({_id:ObjectId("61caa09ee0782536660494d9")})
#查询分类为“travel”、收藏数超过60个的book文档：
db.books.find({type:"travel",favCount:{$gt:60}})
1
2
3
4
5
6

查询条件对照表

查询逻辑对照表

查询逻辑运算符

• $lt: 存在并小于
• $lte: 存在并小于等于
• $gt: 存在并大于
• $gte: 存在并大于等于
• $ne: 不存在或存在但不等于
• $in: 存在并在指定数组中
• $nin: 不存在或不在指定数组中
• $or: 匹配两个或多个条件中的一个
• $and: 匹配全部条件

排序分页

• 指定排序

在MongoDB中使用sort()方法对数据进行排序

#指定按收藏数（favCount）降序返回
db.books.find({type:"travel"}).sort({favCount:-1})
1
2

• 分页查询

skip用于指定跳过记录数，limit则用于限定返回结果数量

db.books.find().skip(8).limit(4)
1

正则表达式匹配查询

MongoDB使用$regex操作符来设置匹配字符串的正则表达式

//使用正则表达式查找type包含 so 字符串的book
db.books.find({type:{$regex:"so"}})
//或者
db.books.find({type:/so/})
1
2
3
4

3.3、更新文档

可以用update命令对指定的数据进行更新，命令的格式如下：

db.collection.update(query,update,options)
1

• query：描述更新的查询条件
• update：描述更新的动作及新的内容；
• update：描述更新的动作及新的内容；
  • upsert: 可选，如果不存在update的记录，是否插入新的记录。默认false，不插入
  • multi: 可选，是否按条件查询出的多条记录全部更新。 默认false,只更新找到的第一条记录
  • writeConcern :可选，决定一个写操作落到多少个节点上才算成功。

更新操作符

更新单个文档

某个book文档被收藏了，则需要将该文档的favCount字段自增

db.books.update({_id:ObjectId("61caa09ee0782536660494d9")},{$inc:{favCount:1}})
1

更新多个文档

默认情况下，update命令只在更新第一个文档之后返回，如果需要更新多个文档，则可以使用multi选项。

将分类为’novel’的文档增加发布时间(publishedDate)

db.books.update({type:"novel"},{$set:{publishedDate:new Date()}},{"multi":true})
1

multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件 查出来多条记录全部更新

update命令的选项配置较多，为了简化使用还可以使用一些快捷命令:

• updateOne: 更新单个文档
• updateMany: 更新多个文档
• replaceOne: 替换单个文档

使用upsert命令

upsert是一种特殊的更新，其表现为如果目标文档不存在，则执行插入命令

db.books.update(
{title:"my book"},
{$set:{tags:["nosql","mongodb"],type:"none",author:"lili"}},
{upsert:true}
)
1
2
3
4
5

nMatched、nModified都为0，表示没有文档被匹配及更新，nUpserted=1提示执行了upsert动作

实现replace语义

update命令中的更新描述（update）通常由操作符描述，如果更新描述中不包含任何操作符，那么 MongoDB会实现文档的replace语义

db.books.update(
{title:"my book"},
{justTitle:"my first book"}
)
1
2
3
4

如果没有使用操作符的话，这个替换，是对文档的一个替换

findAndModify命令

findAndModify兼容了查询和修改指定文档的功能，findAndModify只能更新单个文档

//将某个book文档的收藏数（favCount）加1
db.books.findAndModify({
    query:{_id:ObjectId("62c41650a6a10cd974bac894")},
    update:{$inc:{favCount:1}}
})
1
2
3
4
5

该操作会返回符合查询条件的文档数据，并完成对文档的修改。

默认情况下，findAndModify会返回修改前的旧数据，如果希望返回修改后的数据，则可以指定new选项

db.books.findAndModify({
    query:{_id:ObjectId("62c41650a6a10cd974bac894")},
    update:{$inc:{favCount:1}},
    new: true
})
1
2
3
4
5

与findAndModify语义相近的命令如下：

• findOneAndUpdate: 更新单个文档并返回更新前(或更新后)的文档
• findOneAndReplace: 替换单个文档并返回替换前(或替换后的文档)

3.4、删除文档

• remove 命令需要配合查询条件使用；
• 匹配查询条件的文档会被删除；
• 指定一个空文档条件会删除所有文档；

示例:

db.user.remove({age:28})// 删除age 等于28的记录
db.user.remove({age:{$lt:25}}) // 删除age 小于25的记录
db.user.remove( { } ) // 删除所有记录
db.user.remove() //报错
1
2
3
4

remove命令会删除匹配条件的全部文档，如果希望明确限定只删除一个文档，则需要指定justOne参 数，命令格式如下

db.collection.remove(query,justOne)
1

例如： 删除满足type:novel条件的首条记录

db.books.remove({type:"novel"},true)
1

使用delete删除文档

官方推荐使用 deleteOne() 和 deleteMany() 方法删除文档，语法格式如下

db.books.deleteMany ({}) //删除集合下全部文档
db.books.deleteMany ({ type:"novel" }) //删除 type等于 novel 的全部文档
db.books.deleteOne ({ type:"novel" }) //删除 type等于novel 的一个文档
1
2
3

注意： remove、deleteMany等命令需要对查询范围内的文档逐个删除，如果希望删除整个集合，则使 用drop命令会更加高效

返回被删除文档

remove、deleteOne等命令在删除文档后只会返回确认性的信息，如果希望获得被删除的文档，则可以 使用findOneAndDelete命令

db.books.findOneAndDelete({type:"novel"})
1

除了在结果中返回删除文档，findOneAndDelete命令还允许定义“删除的顺序”，即按照指定顺序删除找 到的第一个文档

db.books.findOneAndDelete({type:"novel"},{sort:{favCount:1}})
1

remove、deleteOne等命令只能按默认顺序删除，利用这个特性，findOneAndDelete可以实现队列的 先进先出。

4、navicat连接MongoDB

1、打开navicat

2、点击密码验证

3、填写相关信息

4、成功连接

5、MongoDB整合SpringBoot

5.1、环境准备

1、引入依赖

<!--spring data mongodb-->
<dependency>
    <groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

1
2
3
4
5
6

2.配置yml

spring:
  data:
    mongodb:
      uri: mongodb://root:root@101.34.254.161:27017/appdb?authSource=admin
      #uri等同于下面的配置
      #database: appdb
      #host: 101.34.254.161
      #port: 27017
      #username: root
      #password: root
      #authentication-database: admin
1
2
3
4
5
6
7
8
9
10
11

连接配置参考文档：https://docs.mongodb.com/manual/reference/connection-string/

3、在测试类注入mongoTemplate

@Autowired
MongoTemplate mongoTemplate;
1
2

5.2、集合操作

@Test
void contextLoads() {
    boolean exists = mongoTemplate.collectionExists("emp");
    // 删除集合
    if (exists) {
        mongoTemplate.dropCollection("emp");
    }
    // 创建集合
    mongoTemplate.createCollection("emp");

}
1
2
3
4
5
6
7
8
9
10
11

5.3、文档操作

相关注解

• @Document
  • 修饰范围: 用在类上
  • 作用: 用来映射这个类的一个对象为mongo中一条文档数据
  • 属性:( value 、collection )用来指定操作的集合名称
• @Id
  • 修饰范围：用在成员变量、方法上
  • 作用 : 用来将成员变量的值映射为文档_id值
• @Field
  • 修饰范围: 用在成员变量、方法上
  • 作用:用来指定此成员变量不参与文档的序列化
• @Transient
  • 修饰范围:用在成员变量、方法上
  • 作用:用来指定此成员变量不参与文档的序列化

创建实体

/**
 * 对应emp集合中的一个文档
 */
@Document("emp")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    /**
     * 映射文档中的_id
     */
    @Id
    private Integer id;
    @Field("username")
    private String name;
    @Field
    private int age;
    @Field
    private Double salary;
    @Field
    private Date birthday;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

添加文档

insert方法返回值是新增的Document对象，里面包含了新增后id的值。如果集合不存在会自动创建集 合。通过Spring Data MongoDB还会给集合中多加一个class的属性，存储新增时Document对应Java中 类的全限定路径。这么做为了查询时能把Document转换为Java类型

添加一条记录：

@Test
void addDocTest(){
    Employee employee = new Employee(1,"小明",12,23.23,new Date());
    mongoTemplate.insert(employee);
}
1
2
3
4
5

查看数据库发现多了一个字段，是为了我们获取的时候可以装换为Java类型

批量添加

@Test
void addDocTest() {

    Employee employee = new Employee(1, "小明", 12, 23.23, new Date());
    mongoTemplate.insert(employee);
    // sava: _id存在时更新数据
    //mongoTemplate.save(employee);
    // insert： _id存在抛出异常 支持批量操作
    List<Employee> list = Arrays.asList(
        new Employee(2,"张三",15,232.0,new Date()),
        new Employee(3,"李四",35,122.0,new Date()),
        new Employee(4,"王五",45,232.0,new Date()),
        new Employee(5,"赵六",55,2432.0,new Date()),
        new Employee(6,"张七",75,232.0,new Date()),
        new Employee(7,"王八",65,2343.0,new Date())
    );
    mongoTemplate.insert(list,Employee.class);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.4、查询文档

Criteria是标准查询的接口，可以引用静态的Criteria.where的把多个条件组合在一起，就可以轻松地将 多个方法标准和查询连接起来，方便我们操作查询语句。

查询操作

@Test
void testSelect(){
    System.out.println("=====查询所有文档=====");
    //查询所有文档
    List<Employee> employeeList = mongoTemplate.findAll(Employee.class);
    employeeList.forEach(System.out::println);
    System.out.println("=====根据id查询=====");
    // 根据id查询
    Employee employee = mongoTemplate.findById(1, Employee.class);
    System.out.println(employee);
    System.out.println("=====findOne返回第一个文档=====");
    // 返回第一个文档
    Employee one = mongoTemplate.findOne(new Query(), Employee.class);
    System.out.println(one);
    System.out.println("=====条件查询=====");
    // new Query()表示没有条件
    // 查询年龄大于等于12的员工
    mongoTemplate.find(new Query(Criteria.where("age").gte(12)),Employee.class).forEach(System.out::println);
    // 查询年龄大于12小于50的员工
    new Query(Criteria.where("age").gt(12).lt(50));
    // 正则查询(模糊查询) java中正则不需要有//
    new Query(Criteria.where("name").regex("张"));


    // and or 多条件查询
    // and 查询年龄大于25且姓名包含张的员工
    Criteria criteria = new Criteria();
    new Query(criteria.andOperator(Criteria.where("age").gt(25),Criteria.where("name").regex("张")));
    // or
    new Query(criteria.orOperator(Criteria.where("age").gt(25),Criteria.where("name").regex("张")));

    // sort排序
    new Query().with(Sort.by(Sort.Order.desc("age")));
    // skip limit分页
    new Query().with(Sort.by(Sort.Order.desc("salary")))
        // 跳过记录数
        .skip(0)
        // 显示记录数
        .limit(4);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

@Test
void testJson() {
    // 使用json字符串方式查询
    // 等值查询
    // String json = "{name:'张三'}";
    // 多条件查询
    String json = "{$or:[{age:{$gt:25}},{salary:{$gte:13}}]}";
    Query query = new BasicQuery(json);
    // 结果
    mongoTemplate.find(query,Employee.class).forEach(System.out::println);
}
1
2
3
4
5
6
7
8
9
10
11

5.5、更新文档

在Mongodb中无论是使用客户端API还是使用Spring Data，更新返回结果一定是受行数影响。如果更新后的结果和更新前的结果是相同，返回0。

• updateFirst() 只更新满足条件的第一条记录
• updateMulti() 更新所有满足条件的记录
• upsert() 没有符合条件的记录则插入数据

@Test
void testUpdate(){
    // query设置查询条件
    Query query = new Query(Criteria.where("age").gte(23));
    System.out.println("======更新前======");
    mongoTemplate.find(query,Employee.class).forEach(System.out::println);
    Update update = new Update();
    // 设置更新属性
    update.set("age",23);
    // updateFirst()只更新满足条件的第一条记录
    // UpdateResult updateResult = mongoTemplate.updateFirst(query, update, Employee.class);
    // updateMulti()更新所有满足
    // UpdateResult updateResult = mongoTemplate.updateMulti(query, update, Employee.class);
    //upsert()没有符合条件的记录则插入数据
    //update.setOnInsert("id",11); // 如果是插入的话则指定id
    UpdateResult updateResult = mongoTemplate.upsert(query, update,
                                                     Employee.class);
    // 返回修改的记录数
    System.out.println(updateResult.getModifiedCount());
    System.out.println("======更新后======");
    mongoTemplate.find(query,Employee.class).forEach(System.out::println);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5.6、删除文档

/**
     * 删除文档
     */
@Test
public void testDelete() {
    //删除所有文档
    //mongoTemplate.remove(new Query(),Employee.class);
    //条件删除
    Query query = new Query(Criteria.where("salary").gte(10000));
    mongoTemplate.remove(query, Employee.class);
}
1
2
3
4
5
6
7
8
9
10
11

6、聚合操作

聚合操作处理数据记录并返回计算结果(诸如统计平均值，求和等)。聚合操作组值来自多个文档，可以对 分组数据执行各种操作以返回单个结果。聚合操作包含三类：单一作用聚合、聚合管道、MapReduce。

• 单一作用聚合：提供了对常见聚合过程的简单访问，操作都从单个集合聚合文档。
• 聚合管道是一个数据聚合的框架，模型基于数据处理流水线的概念。文档进入多级管道，将文档转 换为聚合结果。
• MapReduce操作具有两个阶段：处理每个文档并向每个输入文档发射一个或多个对象的map阶 段，以及reduce组合map操作的输出阶段。

6.1、单一作用集合

MongoDB提供 db.collection.estimatedDocumentCount(), db.collection.count(), db.collection.distinct() 这类单一作用的聚合函数。 所有这些操作都聚合来自单个集合的文档。虽然这 些操作提供了对公共聚合过程的简单访问，但它们缺乏聚合管道和map-Reduce的灵活性和功能

#检索books集合中所有文档的计数
db.books.estimatedDocumentCount()
#计算与查询匹配的所有文档
db.books.count({favCount:{$gt:50}})
#返回不同type的数组
db.books.distinct("type")
#返回收藏数大于90的文档不同type的数组
db.books.distinct("type",{favCount:{$gt:90}})
1
2
3
4
5
6
7
8

注意：在分片群集上，如果存在孤立文档或正在进行块迁移，则db.collection.count()没有查询谓词可能 导致计数不准确。要避免这些情况，请在分片群集上使用 db.collection.aggregate()方法

6.2、聚合管道

什么是 MongoDB 聚合框架

MongoDB 聚合框架（Aggregation Framework）是一个计算框架，它可以：

• 作用在一个或几个集合上；
• 对集合中的数据进行的一系列运算；
• 将这些数据转化为期望的形式；

从效果而言，聚合框架相当于 SQL 查询中的GROUP BY、 LEFT OUTER JOIN 、 AS等。

管道（Pipeline）和阶段（Stage）

整个聚合运算过程称为管道（Pipeline），它是由多个阶段（Stage）组成的， 每个管道：

• 接受一系列文档（原始数据）；
• 每个阶段对这些文档进行一系列运算；
• 结果文档输出给下一个阶段；

聚合管道操作语法

pipeline = [$stage1, $stage2, ...$stageN];
db.collection.aggregate(pipeline, {options})
1
2

• pipelines 一组数据聚合阶段。除$out、$Merge和$geonear阶段之外，每个阶段都可以在管道中 出现多次。
• options 可选，聚合操作的其他参数。包含：查询计划、是否使用临时文件、 游标、最大操作时 间、读写策略、强制索引等等

常用的管道聚合阶段

文档：[[Aggregation Pipeline Stages)](Aggregation Pipeline Stages — MongoDB Manual)

数据准备

准备数据集，执行脚本

vim book2.js进行编写，然后利用load("book2.js")进行加载

var tags = ["nosql","mongodb","document","developer","popular"];
var types = ["technology","sociality","travel","novel","literature"];
var books=[];
for(var i=0;i<50;i++){
	var typeIdx = Math.floor(Math.random()*types.length);
	var tagIdx = Math.floor(Math.random()*tags.length);
	var tagIdx2 = Math.floor(Math.random()*tags.length);
	var favCount = Math.floor(Math.random()*100);
	var username = "xx00"+Math.floor(Math.random()*10);
	var age = 20 + Math.floor(Math.random()*15);
	var book = {
		title: "book-"+i,
		type: types[typeIdx],
		tag: [tags[tagIdx],tags[tagIdx2]],
		favCount: favCount,
		author: {name:username,age:age}
	};
	books.push(book)
}
db.books2.insertMany(books);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$project

投影操作， 将原始字段投影成指定名称， 如将集合中的 title 投影成 name

db.books2.aggregate([{$project:{name:"$title"}}])
1

$project 可以灵活控制输出文档的格式，也可以剔除不需要的字段

db.books2.aggregate([{$project:{name:"$title",_id:0,type:1,author:1}}])
1

从嵌套文档中排除字段(author里面又是一个新的文档)

db.books2.aggregate([
{$project:{name:"$title",_id:0,type:1,"author.name":1}}
])
或者
db.books2.aggregate([
{$project:{name:"$title",_id:0,type:1,author:{name:1}}}
])
1
2
3
4
5
6
7

$match

$match用于对文档进行筛选，之后可以在得到的文档子集上做聚合，$match可以使用除了地理空间之 外的所有常规查询操作符，在实际应用中尽可能将$match放在管道的前面位置。这样有两个好处：一是可以快速将不需要的文档过滤掉，以减少管道的工作量；二是如果再投射和分组之前执行$match，查询 可以使用索引。

db.books2.aggregate([{$match:{type:"technology"}}])
1

筛选管道操作和其他管道操作配合时候时，尽量放到开始阶段，这样可以减少后续管道操作符要操作的 文档数，提升效率

$count

计数并返回与查询匹配的结果数

db.books2.aggregate([ 
	{$match:{type:"technology"}}, {$count: "type_count"}
])
1
2
3

$match阶段筛选出type匹配technology的文档，并传到下一阶段；

$count阶段返回聚合管道中剩余文档的计数，并将该值分配给type_count

$group

按指定的表达式对文档进行分组，并将每个不同分组的文档输出到下一个阶段。输出文档包含一个_id字 段，该字段按键包含不同的组。 输出文档还可以包含计算字段，该字段保存由$group的_id字段分组的一些accumulator表达式的值。 $group不会输出具体的文档而只是统计信息。

{ $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ...
} }
1
2

• d字段是必填的;但是，可以指定id值为null来为整个输入文档计算累计值。
• 剩余的计算字段是可选的，并使用运算符进行计算。
• _id和表达式可以接受任何有效的表达式。

accumulator操作符

$group阶段的内存限制为100M。默认情况下，如果stage超过此限制，$group将产生错误。但是，要 允许处理大型数据集，请将allowDiskUse选项设置为true以启用$group操作以写入临时文件。

book的总数，收藏总数和收藏平均值

db.books2.aggregate([
{$group:{_id:null,count:{$sum:1},pop:{$sum:"$favCount"},avg:
{$avg:"$favCount"}}}
])
1
2
3
4

统计每个作者的book收藏总数

db.books2.aggregate([
{$group:{_id:"$author.name",pop:{$sum:"$favCount"}}}
])
1
2
3

统计每个作者的每本book的收藏数

db.books2.aggregate([
{$group:{_id:{name:"$author.name",title:"$title"},pop:{$sum:"$favCount"}}}
])

1
2
3
4

每个作者的book的type合集

db.books2.aggregate([
{$group:{_id:"$author.name",types:{$addToSet:"$type"}}}
])
1
2
3

$unwind

可以将数组拆分为单独的文档

v3.2+支持如下语法：

{
	$unwind:
	  {
		#要指定字段路径，在字段名称前加上$符并用引号括起来。
		path: <field path>,
		#可选,一个新字段的名称用于存放元素的数组索引。该名称不能以$开头。
		includeArrayIndex: <string>,
		#可选，default :false，若为true,如果路径为空，缺少或为空数组，则			$unwind输出文档
		preserveNullAndEmptyArrays: <boolean>
} }
1
2
3
4
5
6
7
8
9
10

姓名为xx006的作者的book的tag数组拆分为多个文档

db.books2.aggregate([
{$match:{"author.name":"xx006"}},
{$unwind:"$tag"}
])
1
2
3
4

每个作者的book的tag合集

db.books2.aggregate([
{$unwind:"$tag"},
{$group:{_id:"$author.name",types:{$addToSet:"$tag"}}}
])
1
2
3
4

案列

示例数据

db.books2.insert([
{
"title" : "book-51",
"type" : "technology",
"favCount" : 11,
"tag":[],
"author" : {
"name" : "ll",
"age" : 28
}
},{
"title" : "book-52",
"type" : "technology",
"favCount" : 15,
"author" : {
"name" : "ll",
"age" : 28
}
},{
"title" : "book-53",
"type" : "technology",
"tag" : [
"nosql",
"document"
],
"favCount" : 20,
"author" : {
"name" : "ll",
"age" : 28
}
}])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

测试

# 使用includeArrayIndex选项来输出数组元素的数组索引
db.books2.aggregate([
{$match:{"author.name":"ll"}},
{$unwind:{path:"$tag", includeArrayIndex: "arrayIndex"}}
])

1
2
3
4
5
6

发现：只输出tag不为null的数据，并且多了个数组加下标的字段

# 使用preserveNullAndEmptyArrays选项在输出中包含缺少size字段，null或空数组的文档
db.books2.aggregate([
{$match:{"author.name":"ll"}},
{$unwind:{path:"$tag", preserveNullAndEmptyArrays: true}}
])
1
2
3
4
5

发现：无论是tag是否为null，全部可以进行输出。

$limit

限制传递到管道中下一阶段的文档数

db.books2.aggregate([
{$limit : 5 }
])
1
2
3

此操作仅返回管道传递给它的前5个文档。 $limit对其传递的文档内容没有影响。

注意：当$sort在管道中的$limit之前立即出现时，$sort操作只会在过程中维持前n个结果，其中n是指 定的限制，而MongoDB只需要将n个项存储在内存中。

$skip

跳过进入stage的指定数量的文档，并将其余文档传递到管道中的下一个阶段

db.books2.aggregate([
{$skip : 5 }
])
1
2
3

$sort

对所有输入文档进行排序，并按排序顺序将它们返回到管道

语法:

{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }
1

要对字段进行排序，请将排序顺序设置为1或-1，以分别指定升序或降序排序，如下例所示：

db.books.aggregate([
{$sort : {favCount:-1,title:1}}
])
1
2
3

$lookup

Mongodb 3.2版本新增，主要用来实现多表关联查询， 相当关系型数据库中多表关联查询。每个输入 待处理的文档，经过$lookup 阶段的处理，输出的新文档中会包含一个新生成的数组（可根据需要命名 新key ）。数组列存放的数据是来自被Join集合的适配文档，如果没有，集合为空（即 为[ ])

语法：

db.collection.aggregate([{
	  $lookup: {
             from: "<collection to join>",
             localField: "<field from the input documents>",
	 		 foreignField: "<field from the documents of the from collection>",
   			 as: "<output array field>"
           }
})

1
2
3
4
5
6
7
8
9

注意：null = null 此为真

其语法功能类似于下面的伪SQL语句

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT *
                               FROM <collection to join>
                               WHERE <foreignField>=                                                                    <collection.localField>);

1
2
3
4
5
6

案例

数据准备

db.customer.insert({customerCode:1,name:"customer1",phone:"13112345678",address:
"test1"})
db.customer.insert({customerCode:2,name:"customer2",phone:"13112345679",address:
"test2"})
db.order.insert({orderId:1,orderCode:"order001",customerCode:1,price:200})
db.order.insert({orderId:2,orderCode:"order002",customerCode:2,price:400})
db.orderItem.insert({itemId:1,productName:"apples",qutity:2,orderId:1})
db.orderItem.insert({itemId:2,productName:"oranges",qutity:2,orderId:1})
db.orderItem.insert({itemId:3,productName:"mangoes",qutity:2,orderId:1})
db.orderItem.insert({itemId:4,productName:"apples",qutity:2,orderId:2})
db.orderItem.insert({itemId:5,productName:"oranges",qutity:2,orderId:2})
db.orderItem.insert({itemId:6,productName:"mangoes",qutity:2,orderId:2})
1
2
3
4
5
6
7
8
9
10
11
12

关联查询(customer与order)

db.customer.aggregate([
	{$lookup: {
		from: "order",  #关联的表
		localField: "customerCode", #自己的关联表字段
		foreignField: "customerCode", # 关联的表的表字段
		as: "customerOrder" #别名
	   }
	}
])
1
2
3
4
5
6
7
8
9

关联查询(order与orderItem与customer)

db.order.aggregate([
	{$lookup: {
		from: "customer",
		localField: "customerCode",
		foreignField: "customerCode",
		as: "curstomer"
	   }
	},
	{$lookup: {
		from: "orderItem",
		localField: "orderId",
		foreignField: "orderId",
		as: "orderItem"
	   }
}
])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

聚合操作示例1

统计每个分类的book文档数量

db.books.aggregate([
{$group:{_id:"$type",total:{$sum:1}}},
{$sort:{total:-1}}
])
1
2
3
4

标签的热度排行，标签的热度则按其关联book文档的收藏数（favCount）来计算

db.books.aggregate([
	{$match:{favCount:{$gt:0}}},
	{$unwind:"$tag"},
	{$group:{_id:"$tag",total:				{$sum:"$favCount"}}},
	{$sort:{total:-1}}
])

1
2
3
4
5
6
7

1. $match阶段：用于过滤favCount=0的文档。
2. $unwind阶段：用于将标签数组进行展开，这样一个包含3个标签的文档会被拆解为3个条目。
3. $group阶段：对拆解后的文档进行分组计算，$sum："$favCount"表示按favCount字段进行累 加。
4. $sort阶段：接收分组计算的输出，按total得分进行排序

聚合操作示例二

导入邮政编码数据集：https://media.mongodb.org/zips.json

复制下来，放入记事本并重命名为zips.json即可。

使用mongoimport工具导入数据[[Download MongoDB Tools](Download MongoDB Command Line Database Tools | MongoDB)

下载完成后，打开bin目录进行cmd

mongoimport -h 101.34.254.161 -d appdb -u root -p root --authenticationDatabase=admin -c zips --file C:\Users\YLi_Jing\Desktop\zips.json
1

h,–host ：代表远程连接的数据库地址，默认连接本地Mongo数据库；

-port : 远程端口，默认为27017

-u,–username：代表连接远程数据库的账号，如果设置数据库的认证，需要指定用户账号

-p,–password：代表连接数据库的账号对应的密码

-d,–db：代表连接的数据库；

-c,–collection：代表连接数据库中的集合

-f, --fields：代表导入集合中的字段

–type : 代表导入的文件类型，包括csv和json,tsv文件，默认json格式

–file：导入的文件名称

–headerline：导入csv文件时，指明第一行是列名，不需要导入

数据成功导入。

返回人口超过1000万的州

db.zips.aggregate( [
	{ $group: { _id: "$state", totalPop: { $sum: "$pop" } } },
	{ $match: { totalPop: { $gt: 10*1000*1000 } } }
] )
1
2
3
4

这个聚合操作的等价SQL是：

SELECT state, SUM(pop) AS totalPop
FROM zips
GROUP BY state
HAVING totalPop >= (10*1000*1000)
1
2
3
4

返回各州平均城市人口

db.zips.aggregate( [
	{ $group: { _id: { state: "$state", city: "$city" }, cityPop: { $sum: "$pop" }
} },
	{ $group: { _id: "$_id.state", avgCityPop: { $avg: "$cityPop" } } },
	{ $sort:{avgCityPop:-1}}
] )
1
2
3
4
5
6

按州返回最大和最小的城市

db.zips.aggregate( [
	{ $group:
	   {
		_id: { state: "$state", city: "$city" },
		pop: { $sum: "$pop" }
	   }
	},
	{ $sort: { pop: 1 } },
	{ $group:
	   {
		_id : "$_id.state",
		biggestCity: { $last: "$_id.city" },
		biggestPop: { $last: "$pop" },
		smallestCity: { $first: "$_id.city" },
		smallestPop: { $first: "$pop" }
	   }
	},
	{ $project:
	   { 
		_id: 0,
		state: "$_id",
		biggestCity: { name: "$biggestCity", pop: "$biggestPop" },
		smallestCity: { name: "$smallestCity", pop: "$smallestPop" }
	   }
	},
	{ $sort: { state: 1 } }
] )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6.3、MapReduce

MapReduce操作将大量的数据处理工作拆分成多个线程并行处理，然后将结果合并在一起。MongoDB 提供的Map-Reduce非常灵活，对于大规模数据分析也相当实用。

MapReduce具有两个阶段：

• 将具有相同Key的文档数据整合在一起的map阶段
• 组合map操作的结果进行统计输出的reduce阶段

MapReduce的基本语法：

db.collection.mapReduce(
	function() {emit(key,value);}, //map 函数
	function(key,values) {return reduceFunction}, //reduce 函数
	{
	out: <collection>,
	query: <document>,
	sort: <document>,
	limit: <number>,
	finalize: <function>,
	scope: <document>,
	jsMode: <boolean>,
	verbose: <boolean>,
	bypassDocumentValidation: <boolean>
   }
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• map，将数据拆分成键值对，交给reduce函数
• reduce，根据键将值做统计运算
• out，可选，将结果汇入指定表
• quey，可选筛选数据的条件，筛选的数据送入map
• sort，排序完后，送入map
• limit，限制送入map的文档数
• finalize，可选，修改reduce的结果后进行输出
• scope，可选，指定map、reduce、finalize的全局变量
• jsMode，可选，默认false。在mapreduce过程中是否将数 据转换成bson格式。
• verbose，可选，是否在结果中显示时间，默认false
• bypassDocmentValidation，可选，是否略过数据校验

统计type为travel的不同作者的book文档收藏数**

db.books.mapReduce(
	function(){emit(this.author.name,this.favCount)},
	function(key,values){return Array.sum(values)},
   {
	query:{type:"travel"},
	out: "books_favCount"
   }
)
1
2
3
4
5
6
7
8

6.4、Springboot中整合MongoDB进行聚合操作

基于聚合操作Aggregation.group,mongodb提供的可选表达式

示例：以聚合管道示例2为例

实体结构

@Document("zips")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Zips {
    /**
     * 映射文档中的_id
     */
    @Id
    private String id;
    @Field
    private String city;
    @Field
    private Double[] loc;
    private Integer pop;
    @Field
    private String state;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

返回人口超过1000万的州

db.zips.aggregate( [
	{ $group: { _id: "$state", totalPop: { $sum: "$pop" } } },
	{ $match: { totalPop: { $gt: 10*1000*1000 } } }
] )
1
2
3
4

java实现

@Test
void test1(){
    // $group
    GroupOperation group = Aggregation.group("state")
        .sum("pop")
        .as("totalPop");
    // $match
    MatchOperation match = Aggregation
        .match(Criteria.where("totalPop")
               .gt(10*1000*1000));
    // 按顺序组合每一个聚合步骤
    TypedAggregation<Zips> zipsTypedAggregation = Aggregation.newAggregation(Zips.class, group, match);
    // 执行聚合操作
    AggregationResults<Map> aggregate = mongoTemplate.aggregate(zipsTypedAggregation, Map.class);
    // 取出最终结果
    List<Map> mappedResults = aggregate.getMappedResults();
    for (Map mappedResult : mappedResults) {
        System.out.println(mappedResult);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

返回各州平均城市人口

db.zips.aggregate( [
	{ $group: { _id: { state: "$state", city: "$city" }, cityPop: { $sum: "$pop" }
} },
	{ $group: { _id: "$_id.state", avgCityPop: { $avg: "$cityPop" } } },
	{ $sort:{avgCityPop:-1}}
] )
1
2
3
4
5
6

java实现

@Test
void test2() {
    //$group
    GroupOperation groupOperation = Aggregation.group("state","city")
        .sum("pop").as("cityPop");

    //$group
    GroupOperation groupOperation2 = Aggregation.group("_id.state")
        .avg("cityPop").as("avgCityPop");

    //$sort
    SortOperation sortOperation = Aggregation.sort(Sort.Direction.DESC,"avgCityPop");

    // 按顺序组合每一个聚合步骤
    TypedAggregation<Zips> typedAggregation = Aggregation.newAggregation(Zips.class,
                                                                         groupOperation, groupOperation2,sortOperation);

    //执行聚合操作,如果不使用 Map，也可以使用自定义的实体类来接收数据
    AggregationResults<Map> aggregationResults = mongoTemplate
        .aggregate(typedAggregation, Map.class);
    // 取出最终结果
    List<Map> mappedResults = aggregationResults.getMappedResults();
    for(Map map:mappedResults){
        System.out.println(map);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

按州返回最大和最小的城市

db.zips.aggregate( [
	{ $group:
	   {
		_id: { state: "$state", city: "$city" },
		pop: { $sum: "$pop" }
	   }
	},
	{ $sort: { pop: 1 } },
	{ $group:
	   {
		_id : "$_id.state",
		biggestCity: { $last: "$_id.city" },
		biggestPop: { $last: "$pop" },
		smallestCity: { $first: "$_id.city" },
		smallestPop: { $first: "$pop" }
	   }
	},
	{ $project:
	   { 
		_id: 0,
		state: "$_id",
		biggestCity: { name: "$biggestCity", pop: "$biggestPop" },
		smallestCity: { name: "$smallestCity", pop: "$smallestPop" }
	   }
	},
	{ $sort: { state: 1 } }
] )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

java实现

@Test
void test3() {
    //$group
    GroupOperation groupOperation = Aggregation.group("state", "city")
        .sum("pop").as("pop");

    //$sort
    SortOperation sortOperation = Aggregation.sort(Sort.Direction.ASC, "pop");

    //$group
    GroupOperation groupOperation2 = Aggregation.group("_id.state")
        .last("_id.city").as("biggestCity")
        .last("pop").as("biggestPop")
        .first("_id.city").as("smallestCity")
        .first("pop").as("smallestPop");

    //$project
    ProjectionOperation projectionOperation = Aggregation
        .project("biggestCity", "smallestCity", "state")
        .andExclude("_id")
        .andExpression(" { name: \"$biggestCity\",  pop: \"$biggestPop\" }")
        .as("biggestCity")
        .andExpression("{ name: \"$smallestCity\", pop: \"$smallestPop\" }")
        .as("smallestCity")
        .and("_id").as("state");


    //$sort
    SortOperation sortOperation2 = Aggregation.sort(Sort.Direction.ASC, "state");


    // 按顺序组合每一个聚合步骤
    TypedAggregation<Zips> typedAggregation = Aggregation.newAggregation(Zips.class,
                                                                         groupOperation, sortOperation, groupOperation2, projectionOperation,
                                                                         sortOperation2);

    //执行聚合操作,如果不使用 Map，也可以使用自定义的实体类来接收数据
    AggregationResults<Map> aggregationResults = mongoTemplate
        .aggregate(typedAggregation, Map.class);
    // 取出最终结果
    List<Map> mappedResults = aggregationResults.getMappedResults();
    for (Map map : mappedResults) {
        System.out.println(map);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

7、MongoDB索引

7.1、索引介绍

索引是一种用来快速查询数据的数据结构。B+Tree就是一种常用的数据库索引数据结构，MongoDB 采用B+Tree 做索引，索引创建在colletions上。MongoDB不使用索引的查询，先扫描所有的文档，再 匹配符合条件的文档。 使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率

MongoDB索引数据结构

思考：MongoDB索引数据结构是B-Tree还是B+Tree?

B-Tree说法来源于官方文档，然后就导致了分歧：有人说MongoDB索引数据结构使用的是B-Tree,有的 人又说是B+Tree。

MongoDB官方文档: https://docs.mongodb.com/manual/indexes/

索引的分类

• 按照索引包含的字段数量，可以分为单键索引和组合索引（或复合索引）。
• 按照索引字段的类型，可以分为主键索引和非主键索引。
• 按照索引节点与物理记录的对应方式来分，可以分为聚簇索引和非聚簇索引，其中聚簇索引是指索 引节点上直接包含了数据记录，而后者则仅仅包含一个指向数据记录的指针。
• 按照索引的特性不同，又可以分为唯一索引、稀疏索引、文本索引、地理空间索引等

与大多数数据库一样，MongoDB支持各种丰富的索引类型，包括单键索引、复合索引，唯一索引等一 些常用的结构。由于采用了灵活可变的文档类型，因此它也同样支持对嵌套字段、数组进行索引。通过 建立合适的索引，我们可以极大地提升数据的检索速度。在一些特殊应用场景，MongoDB还支持地理 空间索引、文本检索索引、TTL索引等不同的特性

7.2、索引操作

创建索引

db.collection.createIndex(keys, options)
1

• Key 值为你要创建的索引字段，1 按升序创建索引， -1 按降序创建索引
• 可选参数列表如下：

注意：3.0.0 版本前创建索引方法为 db.collection.ensureIndex()

# 创建索引后台执行
db.values.createIndex({open: 1, close: 1}, {background: true})
# 创建唯一索引
db.values.createIndex({title:1},{unique:true})
1
2
3
4

查看索引占用空间

db.collection.totalIndexSize([is_detail])
1

• is_detail：可选参数，传入除0或false外的任意数据，都会显示该集合中每个索引的大小及总大 小。如果传入0或false则只显示该集合中所有索引的总大小。默认值为false

删除索引

#删除集合指定索引
db.col.dropIndex("索引名称")
#删除集合所有索引
db.col.dropIndexes()
1
2
3
4

7.3、索引类型

单键索引（Single Field Indexes）

在某一个特定的字段上建立索引 mongoDB在ID上建立了唯一的单键索引,所以经常会使用id来进行查 询； 在索引字段上进行精确匹配、排序以及范围查找都会使用此索引

db.books.createIndex({title:1})
1

对内嵌文档创建索引：

复合索引（Compound Index）

复合索引是多个字段组合而成的索引，其性质和单字段索引类似。但不同的是，复合索引中字段的顺 序、字段的升降序对查询性能有直接的影响，因此在设计复合索引时则需要考虑不同的查询场景

db.books.createIndex({type:1,favCount:1})
1

多键索引（Multikey Index）

在数组的属性上建立索引。针对这个数组的任意值的查询都会定位到这个文档,既多个索引入口或者键值 引用同一个文档

准备inventory集合:

db.inventory.insertMany([
{ _id: 5, type: "food", item: "aaa", ratings: [ 5, 8, 9 ] },
{ _id: 6, type: "food", item: "bbb", ratings: [ 5, 9 ] },
{ _id: 7, type: "food", item: "ccc", ratings: [ 9, 5, 8 ] },
{ _id: 8, type: "food", item: "ddd", ratings: [ 9, 5 ] },
{ _id: 9, type: "food", item: "eee", ratings: [ 5, 9, 5 ] }
])
1
2
3
4
5
6
7

创建多键索引

db.inventory.createIndex( { ratings: 1 } )
1

多键索引很容易与复合索引产生混淆，复合索引是多个字段的组合，而多键索引则仅仅是在一个字段上 出现了多键（multi key）。而实质上，多键索引也可以出现在复合字段上

# 创建复合多键索引
db.inventory.createIndex( { item:1,ratings: 1} )
1
2

注意： MongoDB并不支持一个复合索引中同时出现多个数组字段

嵌入文档的索引数组

db.inventory.insertMany([
{
_id: 1,
item: "abc",
stock: [
{ size: "S", color: "red", quantity: 25 },
{ size: "S", color: "blue", quantity: 10 },
{ size: "M", color: "blue", quantity: 50 }
]
},
{
_id: 2,
item: "def",
stock: [
{ size: "S", color: "blue", quantity: 20 },
{ size: "M", color: "blue", quantity: 5 },
{ size: "M", color: "black", quantity: 10 },
{ size: "L", color: "red", quantity: 2 }
]
},
{
_id: 3,
item: "ijk",
stock: [
{ size: "M", color: "blue", quantity: 15 },
{ size: "L", color: "blue", quantity: 100 },
{ size: "L", color: "red", quantity: 25 }
]
}
])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在包含嵌套对象的数组字段上创建多键索引

db.inventory.createIndex( { "stock.size": 1, "stock.quantity": 1 } ) 
1

地理空间索引（Geospatial Index）

在移动互联网时代，基于地理位置的检索（LBS）功能几乎是所有应用系统的标配。MongoDB为地理空 间检索提供了非常方便的功能。地理空间索引（2dsphereindex）就是专门用于实现位置检索的一种特 殊索引。

案例：MongoDB如何实现“查询附近商家"？

假设商家的数据模型如下：

db.restaurant.insert({
	restaurantId: 0,
	restaurantName:"兰州牛肉面",
	location : {
		type: "Point",
		coordinates: [ -73.97, 40.77 ]
		}
})

1
2
3
4
5
6
7
8
9

创建一个2dsphere索引

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

1
2

查询附近10000米商家信息

db.restaurant.find( {
	location:{
		$near :{
			$geometry :{
				type : "Point" ,
				coordinates : [ -73.88, 40.78 ]
			} ,
			$maxDistance:10000
		}
	}
} )

1
2
3
4
5
6
7
8
9
10
11
12

全文索引（Text Indexes）

MongoDB支持全文检索功能，可通过建立文本索引来实现简易的分词检索

db.reviews.createIndex( { comments: "text" } )
1

$text操作符可以在有textindex的集合上执行文本检索。$text将会使用空格和标点符号作为分隔符对检 索字符串进行分词， 并且对检索字符串中所有的分词结果进行一个逻辑上的 OR 操作。

全文索引能解决快速文本查找的需求，比如有一个博客文章集合，需要根据博客的内容来快速查找，则 可以针对博客内容建立文本索引。

案例

数据准备

db.stores.insert(
[
{ _id: 1, name: "Java Hut", description: "Coffee and cakes" },
{ _id: 2, name: "Burger Buns", description: "Gourmet hamburgers" },
{ _id: 3, name: "Coffee Shop", description: "Just coffee" },
{ _id: 4, name: "Clothes Clothes Clothes", description: "Discount clothing"
},
{ _id: 5, name: "Java Shopping", description: "Indonesian goods" }
]
)
1
2
3
4
5
6
7
8
9
10

创建name和description的全文索引

db.stores.createIndex({name: "text", description: "text"})

1
2

测试

通过$text操作符来查寻数据中所有包含“coffee”,”shop”，“java”列表中任何词语的商店

db.stores.find({$text: {$search: "java coffee shop"}})
1

MongoDB的文本索引功能存在诸多限制，而官方并未提供中文分词的功能，这使得该功能的应用场景 十分受限

Hash索引（Hashed Indexes）

不同于传统的B-Tree索引,哈希索引使用hash函数来创建索引。在索引字段上进行精确匹配,但不支持范 围查询,不支持多键hash； Hash索引上的入口是均匀分布的,在分片集合中非常有用

db.users. createIndex({username : 'hashed'})
1

通配符索引（Wildcard Indexes）

MongoDB的文档模式是动态变化的，而通配符索引可以建立在一些不可预知的字段上，以此实现查询 的加速。MongoDB 4.2 引入了通配符索引来支持对未知或任意字段的查询

案例

准备商品数据，不同商品属性不一样

db.products.insert([
	{
		"product_name" : "Spy Coat",
		"product_attributes" : {
		"material" : [ "Tweed", "Wool", "Leather" ],
		"size" : {
			"length" : 72,
			"units" : "inches"
			}
		}
	},
	{
		"product_name" : "Spy Pen",
		"product_attributes" : {
			"colors" : [ "Blue", "Black" ],
			"secret_feature" : {
				"name" : "laser",
				"power" : "1000",
				"units" : "watts",
			   }
		   }
		},
		{
			"product_name" : "Spy Book"
		}
])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

创建通配符索引

db.products.createIndex( { "product_attributes.$**" : 1,"product_name":1 } )
1

测试

通配符索引可以支持任意单字段查询 product_attributes或其嵌入字段：

db.products.find( { "product_attributes.size.length" : { $gt : 60 } } )
db.products.find( { "product_attributes.material" : "Leather" } )
db.products.find( { "product_attributes.secret_feature.name" : "laser" } )
1
2
3

注意事项

• 通配符索引不兼容的索引类型或属性

• 通配符索引是稀疏的，不索引空字段。因此，通配符索引不能支持查询字段不存在的文档

# 通配符索引不能支持以下查询
db.products.find( {"product_attributes" : { $exists : false } } )
db.products.aggregate([
{ $match : { "product_attributes" : { $exists : false } } }
])
1
2
3
4
5

• 通配符索引为文档或数组的内容生成条目，而不是文档/数组本身。因此通配符索引不能支持精确 的文档/数组相等匹配。通配符索引可以支持查询字段等于空文档{}的情况

#通配符索引不能支持以下查询:
db.products.find({ "product_attributes.colors" : [ "Blue", "Black" ] } )
db.products.aggregate([{
$match : { "product_attributes.colors" : [ "Blue", "Black" ] }
}])
1
2
3
4
5