MongoDB 学习

前言

MongoDB是一种非关系型数据库，MongoDB中的记录是一个文档，它是一个由字段和值对（field:value）组成的数据结构。被广泛用于大型数据存储和分布式系统的构建。MongoDB支持的数据模型比传统的关系型数据库更加灵活，支持动态查询和索引，也支持BSON格式的数据存储，这种格式可以支持读取和写入大量的数据。

MySQL 和 MongoDB 对比体系结构

SQL术语/概念	MongoDB术语/概念	解释/说明
database	database	数据库
table	collection	表/集合
row	document	行/文档
column	field	数据字段/域
index	index	索引
table joins		表连接，MongoDB不支持
	嵌入文档	MongoDB通过嵌入式文档来替代多表连接
primary key	primary key	主键，MongoDB自动将_id字段设置为主键

数据类型

MongoDB的最小存储单位就是文档（document）对象。文档（document）对象对应于关系型数据库的行。数据在MongoDB中以BSON（Binary-JSON）文档的格式存储在磁盘上。

数据类型	描述	举例
字符串	UTF-8字符串都可表示为字符串类型的数据	{“x”：“foobar”}
对象id	对象id是文档的12字节的唯一ID	{“X”：Objectld()}
布尔值	真或者假：true或者false	{“x”：true)+
数组	值的集合或者列表可以表示成数组	{“x”：[“a”,“b”,“c”]}
32位整数	类型不可用。JavaScript仅支持64位浮点数，所以32位整数会被自动转换	shell是不支持该类型的，shell中默认会转换成64位浮点数
64位整数	不支持这个类型。shell会使用一个特殊的内嵌文档	shell是不支持该类型的，shell中默认会转换成64位浮点数
64位浮点数	shell中的数字就是这一种类型	{“x”：3.14159，“y”:3}
null	表示空值或者未定义的对象	{“x”：null}
undefined	文档中也可以使用未定义类型	{“x”：undefined)
符号	shell不支持，shell会将数据库中的符号类型的数据自动转换成字符串
正则表达	文档中可以包含正则表达式，采用javaScript的正则式表达式语法	{“x”：/foobar/i)
代码	文档中还可以包含javaScript代码	{“x”：function(){/…*/))
二进制数	二进制数据可以由任意字节的串组成，不过shell中无法使用
最大值/最小值	BSON包括一个特殊类型，表示可能的最大值，shellc中没有这个类型

1、MongoDB 的优势是什么

• 灵活的数据模型：MongoDB支持动态查询和索引，可以支持更大的数据集。
• 分布式扩展：MongoDB可以轻松地横向扩展，支持跨多个服务器分布数据，实现高可用性和负载均衡。
• 大规模数据存储：MongoDB支持海量数据存储，提供非常高的性能和可扩展性。
• 易于使用：MongoDB提供简单的命令行工具和可视化界面，支持多种编程语言，易于使用和自定义。

2、部署

2.1、Windows 系统中的安装启动

1. 第一步：下载安装包
   MongoDB提供了可用于32位和64位系统的预编译二进制包，你可以从MongoDB官网下载安装，MongoDB预编译二进割包下载地址：https://www.mongodb.com/try/download/community

提示：版本的选择：

• MongoDB的版本命名规范如：x.y.z
• y为奇数时表示当前版本为开发版，如：1.5.2、4.1.13
• y为偶数时表示当前版本为稳定版，如：1.6.3、4.0.10
• z是修正版本号，数字越大越好

2. 第二步：解压安装

将压缩包确解压到一个目录中。在解压目录中，手动建立一个目录用于存放数据文件，如data/db

3. 第三步：启动

• 方式1：命令行参数方式启动服务

在bin目录中打开命令行提示符，输入如下命令：

mongod --dbpath=..\data\db

我们在启动信息中可以看到，mongoDB的默认端口是27017，如果我们想改变默认的启动端口，可以通过port来指定端口。

为了方便我们每次启动，可以将安装目录的bin目录设置到环境变量的Path中，bin目录下是一些常用命令，比如
mongod启动服务用的，mongo客户端连接服务用的。

• 方式2：配置文件方式启动服务

在解压目录中新建config文件夹，该文件夹中新建配置文件mongod.conf，内如参考如下：

storage:
#The directory where the mongod instance stores its data.Default value is "\data\db"on windows.
dbPath:D:\软件\mongodb\data

启动方式

mongod -f ../config/mongod.conf
或
mongod --config ../config/mongod.conf

2.2、Shell连接（mongo命令）

在命令提示符输入以下shella命令即可完成登都陆

mongo
或
mongo --host=127.0.0.1 --port=27017

查看已经有的数据库

show databases

退出mongodb

exit

更多参数可以通过帮助查看：

mongo --help

提示：
MongoDB javascript shell是一个基于javascript的释器，故是支持js程序的。

2.3、Compass-图形化界面客户端

到 MongoDB 官网下载 MongoDB Compass
地址：hhttps://www.mongodb.com/try/download/compass 在打开的界面中，输入主机地址、端口等相关信息，点击连接

2.4、Linux系统中的安装启动和连接

1. 先到官网下载压缩包。
2. 上传压缩包到Linux中。
3. 移动解压后的文件夹到指定的目录中。

mv mongodb-linux-x86_64-4.0.10 /usr/local/mongodb

4. 新建几个目录，分别用来存储数据和日志。

# 数据存储目录
mkdir -p /mongodb/single/data/db
# 日志存储目录
mkdir -p /mongodb/single/log

5. 新建并修改配置文件

vi /mongodb/single/mongod.conf

配置文件的内客如下：

systemLog:
	# MongoDB发送所有日志输出的目标指症为文件
information
	destination:file
	# mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
	path:"/mongodb/single/log/mongod.log"
	# 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
	logAppend:true
storage:
	# mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod
	dbPath:"/mongodb/single/data/db"
	journal:
		# 启用或禁用特久性日志以确保数据文件保持有效和可恢复
		enabled:true
processManagement:
	# 启用在后台运行mongos或mongod进程的守护进程模式
	fork:true
net:
	# 服务实例绑定的IP,默认是localhost
	bindIp:localhost,192.168.0.2
	# 绑定的端口，认是27017
	port:27017

6. 启动MongoDB服务

[root@bobohost single]#/usr/local/mongodb/bin/mongod -f /mongodb/single/mongod.conf

注意：如果启动后不是successfully,则是启动失败了。原因基本上就是配置文件有问题。

通过进程来查看服务是否启动了：

[root@bobohost single]#ps -ef |grep mongod

7. 分别使用mongo命令和compass工具来连接测试

提示：如果远程连接不上，需要配置防火墙放行，或直接关闭linux防火墙

# 查看防火墙状态
systemctl status firewalld
# 临时关闭防火墙
systemctl stop firewalld
# 开机禁止启动防火墙
systemctl disable firewalld

8. 停止关闭服务

① 快速关闭方法 kill

kill -9 PID

② 标准的关闭方法

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

3、基本常用命令

3.1、选择和创建数据库

1. 选择和创建数据库的语法格式，如果数据库不存在则自动创建

use 数据库名称

注意：在MongoDB中，创建的数据库会先存放在内存中，当创建一个集合后才持久化到磁盘，集合只有在内容插入后才会创建，就是说，创建集合数据表后要再插入一个文档（记录)，集合才会真正创建。

2. 查看有权限查看的所有的数据库命令

show dbs
或
show databases

3. 查看当前正在使用的数据库命令

db

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

3.2、数据库删除

1. MongoDB别除教据库的语法格式如下，主要用来别除已经持久化的数据库

db.dropDatabase()

3.3、集合操作

3.3.1、集合显示创建

1. 基本语法格式，name是要创建的集合名称

db.createCollection(name)

2. 查看当前库中的表：show tables命令

show collections
或
show tables

3.3.2、集合隐式创建

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

当插入文档时候，如果集合不存在则隐式2创建

3.3.3、集合的删除

# 集合名称 mycollection
db.mycollection.drop()

3.4、文档操作

3.4.1、文档的插入

1. 单条插入使用insert或save方法向集合中插入文档

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

示例

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

2. 批量插入

db.collection.insertMany(
	[<document or array of documents>](json 数组格式),
	{
		writeConcern:<document>,
		ordered:<boolean>
	}

示例

db.comment.insertMany([{
    "articleid": "100000",
    "content": "今天天气真好",
    "userid": "1001",
    "nickname": "Rose",
    "createdatetime": new
    Date(),
    "likenum": NumberInt(10),
    "state": null,
		"note":""
}])

插入时指定了_id，则主键就是该值，如果某条数据插入失败，将会终止插入，但已经插入成功的数据不会回滚掉。因为批量插入由于数据较多容易失败，因此可以使用try catch进行异常捕获处理，测试的时候可以不处理。

try{
   db.comment.insertMany([
  {"_id":"9","articleId":"1001", "content":"吃饭喝水"},
  {"_id":"5","articleId":"1001", "content":"吃饭喝水"},
  {"_id":"6","articleId":"1001", "content":"吃饭喝水"},
]);
} catch(e){
   print(e);
}

3.4.2、文档的查询

1. 查询所有

db.comment.find()
或
db.comment.find({})

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

2. 条件查询

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

如果你只需要返回符合条件的第一条数据相当于limit，我们可以使用findOne命令来实现。语法和find一样。

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

3. 投影查询

① 显示userId、name、_id字段

db.comment.find({userId:"1"}.{userId:1, name:1, _id:1})

② 显示userId、name字段，不显示_id字段

db.comment.find({userId:"1"}.{userId:1, name:1, _id:0})

③ 查询所有数据，只显示_id、userId、name

db.comment.find({}.{userId:1, name:1, _id:1})

3.4.3、文档的更新

1. 覆盖修改（将该条记录完全覆盖）

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

2. 局部修改（使用修改器 $set 来实现，默认只修改第一条数据）

db.comment.update({_id:"1"},{$set:{name:NumberInt(1001)}})

3. 批量局部修改（更新所有用户为1000的数据）

db.comment.update({userId:"1000"},{$set:{name:NumberInt(1001)}},{multi:true})

4. 列值增长的修改

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

3.4.4、文档的删除

1. 删除所有数据

db.comment.remove({})

2. 删除_id = 1的记录

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

3.4.5、文档的分页查询

1. 统计查询

# 统计comment集合的所有的记录数
db.comment.count()
# 统计userId为100的记录条数
db.comment.count({userId:"100"})

2. 分页列表查询

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

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

返回前三条的数据

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

skip方法（跳过前n条数据）

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

分页样例

// 第一页
db.comment.find().skip(0).limit(3)
// 第二页
db.comment.find().skip(3).limit(3)
// 第三页
db.comment.find().skip(6).limit(3)

3.4.6、文档的排序查询

db.COLLECTION_NAME.find().sort({KEY:1})

样例：对userId降序排列，并对number进行升序排列

db.comment.find().sort({userId:-1,number:1})

执行顺序：先sort( )，再是skip( )，最后是limit( )和命令编写顺序无关

3.4.7、正则复杂条件查询

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

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

样例：查询food里包含蛋糕的所有文档

db.comment.find({food:/蛋糕/})

样例：查询food里蛋糕开头的所有文档

db.comment.find({food:/^蛋糕/})

样例：查询food里蛋糕结尾的所有文档

db.comment.find({food:/蛋糕^/})

3.4.8、比较查询

db.集合名称.find({"field":{$gt:value}})  //大于：field>value
db.集合名称.find({"field":{$lt:value}})  //小于：field
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({number:{$gt:NumberInt(700)}})

3.4.9、包含查询

包含使用$in操作符，查询集合中userId字段包含100或101的文档

db.comment.find({userId:{$in:["100","101"]}})

不包含使用$nin操作符，查询集合中userId字段不包含100和101的文档

db.comment.find({userId:{$nin:["100","101"]}})

3.4.10、条件连接查询

查询同时满足两个以上的条件，需要使用$and操作符将条件进行关联，例如：查询集合中number大于等于700并且小于2000的文档

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

查询两个以上条件之间是或者的关系，例如：查询集合中userId为10，或者点赞数小于100的文档记录

db.comment.find({$or:[{userId:"10"}, {number:{$lt:100}}]})

4、索引-Index

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

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

索引是特殊的数据结构，它以易于遍历的形式存储集合数据的一小部分。索引存储特定字段或一组字段的值，按字段值排序。索引项的排序支持有效的相等匹配和基于范围的查询操作。此外，MongoDB还可以使用索引中的排序返回排序结果。

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

4.1、索引的类型

4.1.1、单字段索引

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

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

4.1.2、复合索引

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

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

4.1.3、其他索引

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

• 地理空间索引：为了支持对地理空间坐标数据的有序查询，MongoDB提供了两种特殊的索引；返回结果时使用平面几何的二维索引和返回结果时使用球面几何的二维球面索引。
• 文本索引：MongoDB提供了一种文本索引类型，支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的停止词（例如“the”、“a”、“or”），而将集合的词作为词干，只存根词。
• 哈希索引：为了支持基于散列的分片，MongoDB提供了散列索引类型，它对字段值的散列进行索引。这些索引在其范围内的值分布更加随机，但只支持相等匹配，不支持基于范围的查询。

4.2、索引的管理操作

4.2.1、索引的查看

db.collection.getIndexes()

4.2.2、索引的创建

# 单字段索引
db.collection.createIndex({userId:1})
# 复合索引
db.collection.createIndex({userId:1, name:-1})

4.2.3、索引的移除

# 指定索引的移除
db.collection.dropIndex({userId:1})

# 所有索引的移除（除了_id）
db.collection.dropIndexes()

4.3、执行计划

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

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

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

涵盖的查询

当查询条件和查询的投影仅包含索引字段时，MongoDB直接从索引返回结果，而不是扫描任何文档或将文档带入内存内，这些覆盖的查询可以非常高效（简单来说：只需要查询索引集合就可以获取需要的数据，无需回到实际的集合中查询文档）。

5、MongoTemplate 相关API

5.1、插入

// 1、插入一条数据 insert(),若新增数据的主键已经存在，则会抛 org.springframework.dao.DuplicateKeyException 异常提示主键重复，不保存当前数据
// 可以一次性插入一整个列表，而不用进行遍历操作，效率相对较高
Comment comment1 = new Comment();
comment1.setUserId("1003");
comment1.setState("1");
mongoTemplate.insert(comment1);
// 2、插入一条数据 save(),插入一条数据,若新增数据的主键已经存在，则会对当前已经存在的数据进行修改操作
Comment comment2 = new Comment();
comment2.setUserId("1004");
comment2.setState("2");
mongoTemplate.save(comment2);
// 3、批量插入 insert(),添加对象的集合,对象的实体类.class
List<Comment> list1 = new ArrayList<>();
list1.add(comment1);
list1.add(comment2);
mongoTemplate.insert(list1, Comment.class);
// 4、批量插入 insertAll(),插入的对象集合
List<Comment> list2 = new ArrayList<>();
list2.add(comment1);
list2.add(comment2);
mongoTemplate.insertAll(list2);

5.2、更新

// 1、更新查询结果的第一个值 updateFirst()，mongoTemplate.update() 不建议用
// 方法1 : UpdateResult updateFirst(Query query, Update update, Class entityClass)
// 方法2 : UpdateResult updateFirst(Query query, Update update, String collectionName)
// 方法3 : UpdateResult updateFirst(Query query, Update update, Class entityClass, String collectionName)
// 方法1更新最慢，方法2和方法3差不多（更新条件，更新值，集合对应的实体类.class，集合名称）
Query query1 = new Query();
query1.addCriteria(Criteria.where("userId").is("1003"));

Update update1 = new Update();
update1.set("state", "3");

long start11 = System.currentTimeMillis();
mongoTemplate.updateFirst(query1, update1, Comment.class);
long end11 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法1耗时: " + (end11 - start11));

long start12 = System.currentTimeMillis();
mongoTemplate.updateFirst(query1, update1, "niHao");
long end12 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法2耗时: " + (end12 - start12));

long start13 = System.currentTimeMillis();
mongoTemplate.updateFirst(query1, update1, Comment.class, "niHao");
long end13 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法3耗时: " + (end13 - start13));

// 2、更新所有查询结果 updateMulti()
// 方法1 : UpdateResult updateMulti(Query query, Update update, Class entityClass)
// 方法2 : UpdateResult updateMulti(Query query, Update update, String collectionName)
// 方法3 : UpdateResult updateMulti(Query query, Update update, Class entityClass, String collectionName)
// 方法1更新最慢，方法2和方法3差不多（更新条件，更新值，集合对应的实体类.class，集合名称）
Query query2 = new Query();
query2.addCriteria(Criteria.where("userId").is("1003"));

Update update2 = new Update();
update2.set("state", "3");

long start21 = System.currentTimeMillis();
mongoTemplate.updateMulti(query2, update2, Comment.class);
long end21 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法1耗时: " + (end21 - start21));

long start22 = System.currentTimeMillis();
mongoTemplate.updateMulti(query1, update1, "niHao");
long end22 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法2耗时: " + (end22 - start22));

long start23 = System.currentTimeMillis();
mongoTemplate.updateMulti(query2, update2, Comment.class, "niHao");
long end23 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法3耗时: " + (end23 - start23));

// 3、数据库有就修改查询出的第一条,数据库没有就新增一条 upsert()
// 方法1 : UpdateResult upsert(Query query, Update update, Class entityClass)
// 方法2 : UpdateResult upsert(Query query, Update update, String collectionName)
// 方法3 : UpdateResult upsert(Query query, Update update, Class entityClass, String collectionName)
// 方法1更新最慢，方法2和方法3差不多（更新条件，更新值，集合对应的实体类.class，集合名称）
Query query3 = new Query();
query3.addCriteria(Criteria.where("userId").is("1005"));

Update update3 = new Update();
update3.set("state", "4");

long start31 = System.currentTimeMillis();
mongoTemplate.upsert(query3, update3, Comment.class);
long end31 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法1耗时: " + (end31 - start31));

long start32 = System.currentTimeMillis();
mongoTemplate.upsert(query3, update3, "niHao");
long end32 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法2耗时: " + (end32 - start32));

long start33 = System.currentTimeMillis();
mongoTemplate.upsert(query3, update3, Comment.class, "niHao");
long end33 = System.currentTimeMillis();
System.out.println("==========================================");
System.out.println("方法3耗时: " + (end33 - start33));

5.3、删除

// 1、删除符合条件的记录
// 方法1 : DeleteResult remove(Query query, Update update, Class entityClass)
// 方法2 : DeleteResult remove(Query query, Update update, String collectionName)
// 方法3 : DeleteResult remove(Query query, Update update, Class entityClass, String collectionName)
// （删除条件，集合对应实体类.class，集合名称）

Query query1 = new Query();
query1.addCriteria(Criteria.where("userId").is("1002"));

mongoTemplate.remove(query1, Comment.class);
mongoTemplate.remove(query1, "niHao");
mongoTemplate.remove(query1, Comment.class, "niHao");

// 2、查询出符合条件的结果，并将符合条件的数据删除,只会删除第一条 findAndRemove()
// 方法1 : DeleteResult findAndRemove(Query query, Update update, Class entityClass)
// 方法2 : DeleteResult findAndRemove(Query query, Update update, Class entityClass, String collectionName)
// （删除条件，集合对应实体类.class，集合名称）
Query query2 = new Query();
query2.addCriteria(Criteria.where("userId").is("1003"));

mongoTemplate.findAndRemove(query2, Comment.class);
mongoTemplate.findAndRemove(query2, Comment.class, "niHao");

// 3、查询出符合条件的所有结果，并将符合条件的所有数据删除 findAllAndRemove()
// 方法1 : DeleteResult findAllAndRemove(Query query, Update update, Class entityClass)
// 方法2 : DeleteResult findAllAndRemove(Query query, Update update, String collectionName)
// 方法3 : DeleteResult findAllAndRemove(Query query, Update update, Class entityClass, String collectionName)
// （删除条件，集合对应实体类.class，集合名称）
Query query3 = new Query();
query3.addCriteria(Criteria.where("userId").is("1003"));

mongoTemplate.findAllAndRemove(query3, Comment.class);
mongoTemplate.findAllAndRemove(query3, "niHao");
mongoTemplate.findAllAndRemove(query3, Comment.class, "niHao");

5.4、查询

// 1、查询集合中所有数据，不加条件 findAll()
// 方法1 :  List findAll(Class entityClass)
// 方法2 :  List findAll(Class entityClass, String collectionName)(推荐)
// （集合对应的实体类.class，集合名称）
long start1 = System.currentTimeMillis();
List<Comment> list1 = mongoTemplate.findAll(Comment.class);
long end1 = System.currentTimeMillis();
System.out.println("方法1查询结果总数 : " + list1.size());
System.out.println("方法1耗时: " + (end1 - start1));
System.out.println("==========================================");

long start2 = System.currentTimeMillis();
List<Comment> list2 = mongoTemplate.findAll(Comment.class, "niHao");
long end2 = System.currentTimeMillis();
System.out.println("方法2查询结果总数 : " + list2.size());
System.out.println("方法2耗时: " + (end2 - start2));

// 2、查询符合条件的第一条数据 findOne()
// 方法1 :  T findOne(Query query, Class entityClass)
// 方法2 :  T findOne(Query query, Class entityClass, String collectionName)(推荐)
// （集合对应的实体类.class，集合名称）
Query query = new Query();
Criteria criteria = new Criteria();
criteria.andOperator(Criteria.where("userId").is("1003"), Criteria.where("state").is("4"));
query.addCriteria(criteria);

long start3 = System.currentTimeMillis();
Comment comment3 = mongoTemplate.findOne(query, Comment.class);
long end3 = System.currentTimeMillis();
System.out.println("方法1查询结果 : " + comment3.getId());
System.out.println("方法1耗时: " + (end3 - start3));
System.out.println("==========================================");

long start4 = System.currentTimeMillis();
Comment comment4 = mongoTemplate.findOne(query, Comment.class, "niHao");
long end4 = System.currentTimeMillis();
System.out.println("方法2查询结果 : " + comment4.getId());
System.out.println("方法2耗时: " + (end4 - start4));

// 3、查询符合条件的所有数据 find()
// 方法1 :  List find(Query query, Class entityClass)
// 方法2 :  List find(Query query, Class entityClass, String collectionName) (推荐)
// （集合对应的实体类.class，集合名称）
Query query1 = new Query();
Criteria criteria1 = new Criteria();
criteria1.andOperator(Criteria.where("userId").is("1003"), Criteria.where("state").is("4"));
query1.addCriteria(criteria1);

long start31 = System.currentTimeMillis();
List<Comment> list31 = mongoTemplate.find(query1, Comment.class);
long end31 = System.currentTimeMillis();
System.out.println("方法1查询结果 : " + list31);
System.out.println("方法1耗时: " + (end31 - start31));
System.out.println("==========================================");

long start41 = System.currentTimeMillis();
List<Comment> list32 = mongoTemplate.find(query1, Comment.class, "niHao");
long end41 = System.currentTimeMillis();
System.out.println("方法2查询结果 : " + list32);
System.out.println("方法2耗时: " + (end41 - start41));

// 4、查询符合条件的数量 count()
// 方法1 : long count(Query query, Class entityClass)
// 方法2 : long count(Query query, String collectionName)
// 方法3 : long count(Query query, @Nullable Class entityClass, String collectionName)
Query query2 = new Query();
Criteria criteria2 = new Criteria();
criteria2.andOperator(Criteria.where("userId").is("1003"), Criteria.where("state").is("4"));
query2.addCriteria(criteria2);

long start13 = System.currentTimeMillis();
long count1 = mongoTemplate.count(query2, Comment.class);
long end13 = System.currentTimeMillis();
System.out.println("方法1查询结果总数 : " + count1);
System.out.println("方法1耗时: " + (end13 - start13));
System.out.println("==========================================");

long start23 = System.currentTimeMillis();
long count2 = mongoTemplate.count(query2, "niHao");
long end23 = System.currentTimeMillis();
System.out.println("方法2查询结果总数 : " + count2);
System.out.println("方法2耗时: " + (end23 - start23));
System.out.println("==========================================");

long start33 = System.currentTimeMillis();
long count3 = mongoTemplate.count(query2, Comment.class, "niHao");
long end33 = System.currentTimeMillis();
System.out.println("方法3查询结果总数 : " + count3);
System.out.println("方法3耗时: " + (end33 - start33));
System.out.println("==========================================");

5.5、其他

// 1、andOperator且相当于 and
Criteria criteria1 =
    new Criteria().andOperator(Criteria.where("address").is("魏国"), Criteria.where("sex").is("女"));
// 2、orOperator或相当于or
Criteria criteria2 =
    new Criteria().orOperator(Criteria.where("address").is("魏国"), Criteria.where("height").is("177"));
// 3、andOperator和orOperator联合查询
Criteria criteria3 = new Criteria().andOperator(Criteria.where("sex").is("女"), Criteria.where("age").lt(35));
Criteria criteria4 =
    new Criteria().orOperator(Criteria.where("address").is("魏国"), Criteria.where("weight").is("61"));
Criteria criteria = new Criteria();
criteria.orOperator(criteria3, criteria4);
// 4、in 在范围元素内
List<String> names = new ArrayList<>();
Collections.addAll(names, "关羽", "关凤", "关平");
Criteria criteria5 =
    new Criteria().andOperator(Criteria.where("address").is("蜀国"), Criteria.where("name").in(names));
// 5、nin 不在范围元素内
Criteria criteria6 =
    new Criteria().andOperator(Criteria.where("address").is("蜀国"), Criteria.where("name").nin(names));
// 6、显示是否有该字段数据的值
Criteria criteria7 =
    new Criteria().andOperator(Criteria.where("address").is("中国"), Criteria.where("age").exists(false));
// 7、同一个字段在条件中的正确写法&>,lt,gte,lte,
Criteria criteria8 = new Criteria().andOperator(Criteria.where("insertDt").gte("2020-07-01"),
    Criteria.where("insertDt").lte("2020-07-31"));
// 8、分页查询
int currentPage = 1; // 当前页
int pageSize = 5; // 每页显示记录数
Criteria criteria9 = new Criteria().andOperator(Criteria.where("address").is("蜀国"));
Query query = new Query(criteria9);
query.skip((currentPage - 1) * pageSize).limit(pageSize);
// 另一种方式
// Pageable pageable = new PageRequest((currentPage - 1) * pageSize, pageSize);
// query.with(pageable);
List<Comment> list = mongoTemplate.find(query, Comment.class, "user");
// 查询总记录数
int total = (int)mongoTemplate.count(query, Comment.class, "user");
int totalCount = Integer.parseInt(String.valueOf(total));
// 总页数
int totalPage = 0;
if (totalCount <= pageSize) {
    totalPage = 1;
} else {
    totalPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;
}

System.out.println("总记录数: " + totalCount);
System.out.println("总页数: " + totalPage);
for (Comment comment : list) {
    System.out.println(comment.getId() + "=============" + comment.getUserId());
}
// 9、排序 sort 单个条件排序,多个条件排序
Criteria criteria10 = new Criteria().andOperator(Criteria.where("address").is("魏国"));
Query query2 = new Query(criteria10);

// 方式1 单个条件的排序
// Sort sort = new Sort(Sort.Direction.DESC, "insertDt");

// 方式2 单个条件的排序
Sort sort = Sort.by(Sort.Order.desc("insertDt"));

// 多个条件排序
// Sort sort = Sort.by(Sort.Order.desc("insertDt"),
// Sort.Order.asc("age"));

query2.with(sort);
query2.skip((currentPage - 1) * pageSize).limit(pageSize);
// 10、分组查询
//  GroupByResults group(@Nullable Criteria criteria, String inputCollectionName, GroupBy groupBy,
// Class entityClass)
// （查询条件，集合名称，分组条件，集合对应实体类.class）
Criteria criteria11 = new Criteria().andOperator(Criteria.where("address").is("魏国"));
String reduce = "function reduce(doc,out){" + "var height = parseFloat(doc.height);"
    + "var weight = parseFloat(doc.weight);" + "out.sumHeight += height;" + "out.sumWeight += weight; "
    + "out.address = doc.address" + "}";
GroupBy groupBy =
    new GroupBy("userId").initialDocument("{address:'',sumHeight:0,sumWeight:0}").reduceFunction(reduce);
GroupByResults<Comment> result = mongoTemplate.group(criteria11, "niHao", groupBy, Comment.class);

List list3 = (List)result.getRawResults().get("retval");

list3.forEach(item -> {
    Document doc = (Document)item;
    String address = doc.getString("address");
    Double height = doc.getDouble("sumHeight");
    Double weight = doc.getDouble("sumWeight");
    System.out.println(address + "==" + height + "==" + weight);
});
// 11、 模糊匹配,完全匹配,左匹配,右匹配
// CASE_INSENSITIVE 是不区分大小写，想区分就去掉这个参数
String str = "2";
// 完全匹配
// Pattern pattern = Pattern.compile("^" + str + "$", Pattern.CASE_INSENSITIVE);
// 右匹配
// Pattern pattern = Pattern.compile("^.*" + str + "$", Pattern.CASE_INSENSITIVE);
// 左匹配
// Pattern pattern = Pattern.compile("^" + str + ".*$", Pattern.CASE_INSENSITIVE);
// 模糊匹配
Pattern pattern = Pattern.compile("^.*" + str + ".*$", Pattern.CASE_INSENSITIVE);
Criteria criteria12 =
    new Criteria().andOperator(Criteria.where("userId").is("1003"), Criteria.where("state").regex(pattern));
Query query3 = new Query(criteria12);
List<Comment> list4 = mongoTemplate.find(query3, Comment.class, "niHao");
for (Comment comment : list4) {
    System.out.println(comment.getId() + "==" + comment.getUserId());
}
// 12、简单的聚合查询 aggregate()
//  AggregationResults aggregate(Aggregation aggregation, String collectionName, Class outputType)
// （条件，集合名字，查询结果类型xxx.class）
Criteria criteria13 = new Criteria().andOperator(Criteria.where("insertDt").gte("2020-07-01"),
    Criteria.where("insertDt").lte("2020-07-31"));
Criteria criteria14 = Criteria.where("sex").is("女");
Aggregation aggregation =
    Aggregation.newAggregation(Aggregation.match(criteria13), Aggregation.match(criteria14));
AggregationResults<Comment> result2 = mongoTemplate.aggregate(aggregation, "niHao", Comment.class);
List<Comment> list5 = result2.getMappedResults();
list5.forEach(item -> {
    System.out.println(item.getUserId());
});
// 13、复杂的聚合查询
//  AggregationResults aggregate(Aggregation aggregation, String collectionName, Class outputType)
// （条件，集合名字，查询结果类型xxx.class）
int pageNum1 = 1;
int pageSize1 = 3;
Criteria criteria15 = new Criteria().andOperator(Criteria.where("insertDt").gte("2020-07-01"),
    Criteria.where("insertDt").lte("2020-07-31"));
/**
 * project : 列出所有本次查询的字段，包括查询条件的字段和需要搜索的字段 match : 搜索条件criteria group : 分组的字段，以及聚合相关查询 sum : 求和 count : 数量 max ;
 * 最大值 min : 最小值 avg : 平均值 sort ; 排序 skip&limit：分页查询
 */
Aggregation aggregation2 = Aggregation.newAggregation(Aggregation.match(criteria15),
    // Aggregation.project("address","insertDt","age","name"),
    Aggregation.sort(new Sort(Sort.Direction.DESC, "insertDt")), Aggregation.skip(pageNum1),
    Aggregation.limit(pageSize1), Aggregation.group("address").sum("age").as("sum").count().as("count")
        .max("age").as("max").min("age").as("min").avg("age").as("avg").first("name").as("name"));

AggregationResults<Comment> user = mongoTemplate.aggregate(aggregation2, "user", Comment.class);
List<Comment> results = user.getMappedResults();

for (Comment result1 : results) {
    System.out.println(result1.getId() + "==" + result1.getUserId() + "==" + result1.getState() + "=="
        + result1.getContent() + "==" + result1.getArticleId() + "==" + result1.getParentId());
}