MongoDB 学习

已于 2023-06-05 15:43:33 修改
阅读量1.2k 收藏 6
点赞数 2
分类专栏： java 文章标签： mongodb java
于 2023-06-01 15:31:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy139926/article/details/130989379
版权

文章目录

前言

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

MySQL 和 MongoDB 对比体系结构

SQL术语/概念MongoDB术语/概念解释/说明
databasedatabase数据库
tablecollection表/集合
rowdocument行/文档
columnfield数据字段/域
indexindex索引
table joins表连接，MongoDB不支持
嵌入文档MongoDB通过嵌入式文档来替代多表连接
primary keyprimary 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是修正版本号，数字越大越好
  1. 第二步：解压安装

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

  1. 第三步：启动
  • 方式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
  1. 新建几个目录，分别用来存储数据和日志。
# 数据存储目录
mkdir -p /mongodb/single/data/db
# 日志存储目录
mkdir -p /mongodb/single/log
  1. 新建并修改配置文件
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
  1. 启动MongoDB服务
[root@bobohost single]#/usr/local/mongodb/bin/mongod -f /mongodb/single/mongod.conf

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

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

[root@bobohost single]#ps -ef |grep mongod
  1. 分别使用mongo命令和compass工具来连接测试

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

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

① 快速关闭方法 kill

kill -9 PID

② 标准的关闭方法

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

3、基本常用命令

在这里插入图片描述

3.1、选择和创建数据库

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

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

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

3.2、数据库删除

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

3.3、集合操作

3.3.1、集合显示创建

  1. 基本语法格式，name是要创建的集合名称
db.createCollection(name)
  1. 查看当前库中的表：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":""
})
  1. 批量插入
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支持的任意类型。

  1. 条件查询
db.comment.find({userid:'1001'})

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

db.comment.findOne({userid:'1001'})
  1. 投影查询

① 显示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)})
  1. 局部修改（使用修改器 $set 来实现，默认只修改第一条数据）
db.comment.update({_id:"1"},{$set:{name:NumberInt(1001)}})
  1. 批量局部修改（更新所有用户为1000的数据）
db.comment.update({userId:"1000"},{$set:{name:NumberInt(1001)}},{multi:true})
  1. 列值增长的修改
db.comment.update({_id:"3"},{$inc:{num:NumberInt(1)}})

3.4.4、文档的删除

  1. 删除所有数据
db.comment.remove({})
  1. 删除_id = 1的记录
db.comment.remove({_id:"1"})

3.4.5、文档的分页查询

  1. 统计查询
# 统计comment集合的所有的记录数
db.comment.count()
# 统计userId为100的记录条数
db.comment.count({userId:"100"})
  1. 分页列表查询

使用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<value
db.集合名称.find({"field":{$gte:value}}) //大于等于：field>=value
db.集合名称.find({"field":{$lte:value}}) //小于等于：field<=value
db.集合名称.find({"field":{$ne:value}})  //不等于：field!=value

样例：查询数量大于700的记录

db.comment.find({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 : <T> List<T> findAll(Class<T> entityClass)
// 方法2 : <T> List<T> findAll(Class<T> 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> T findOne(Query query, Class<T> entityClass)
// 方法2 : <T> T findOne(Query query, Class<T> 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 : <T> List<T> find(Query query, Class<T> entityClass)
// 方法2 : <T> List<T> find(Query query, Class<T> 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、同一个字段在条件中的正确写法&&gt,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、分组查询
// <T> GroupByResults<T> group(@Nullable Criteria criteria, String inputCollectionName, GroupBy groupBy,
// Class<T> 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()
// <O> AggregationResults<O> aggregate(Aggregation aggregation, String collectionName, Class<O> 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、复杂的聚合查询
// <O> AggregationResults<O> aggregate(Aggregation aggregation, String collectionName, Class<O> 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());
}
跪在镜子前喊帅
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MongoDB学习MongoDB学习MongoDB学习
09-21
MongoDB学习MongoDB学习MongoDB学习
Mongodb——快速入门，2个小时足够了
挣钱买房买车的博客
05-23 1117
Mongodb用来应对“三高”问题：高并发：对数据库高并发读写的需求。高性能：对海量数据的高效存储和访问的需求。高可用：对数据库的高扩展性和高可用性的需求。MySQL数据库在面临这“三高”时，显得力不从心，所以学习Mongodb才更能丰富业务场景的处理能力。MongoDB 是一个开源的 NoSQL 数据库，具有高可扩展性、灵活性和可靠性等优点，适合于处理分布式、大规模和敏捷的数据存储需求。
MongoDB快速入门到精通，看这篇就够了
qq_36756227的博客
03-14 1019
mongodb核心概念讲解，应用场景介绍，与sql方式区别对比等，并学习如何使用shell命令操作mongodb，以及使用Java进行CRUD操作，最后带你了解常见三种集群架构，以及生产环境真实部署案例。
MongoDB ：第七章：总结一下学习MongoDB的心得
最新发布
2401_83329718的博客
03-30 806
{ “dropped” : “runoob”, “ok” : 1 }先切换到数据库 runoob：switched to db test再执行创建site集合命令{ “ok” : 1 }6142800, max : 10000 } ){ “ok” : 1 }capped : true固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。autoIndexId : true为 true，自动在 _id 字段创建索引。默认为 false。先切换
一.MongoDB入门-MongDB介绍和安装
墨家巨子@俏如来
03-30 1867
前言 该文章是MongoDB系列入门文章，还不会MongoDB的同学可以根据该系列文章进行学习，并运用于实际项目中，如果你对于MongoDB已经用的非常熟了可以跳过。写这个文章的初衷是很多童鞋公司用到这门技术，自己却还不会跑来问我要资料，所以这里整理一下MongoDB相关知识，同时也是对自己的一次沉淀。学习使用老鸟飞过，欢迎交流。 一.MongoDB认识 1.什么是MongoDB 下面引用百度百科的解释来介绍MongoDB MongoDB是一个基于分布式文件存储 [1] 的数据库。由C++语言编写。旨在
MongoDB快速上手.黑马跟学(一)
心向阳光的天域的博客
04-01 694
Mongodb数据库的安装、基本语法、快速上手
MongoDB超详细教程（保姆级）
热门推荐
efew212efe的博客
05-01 6万+
MongoDB 一、简介 1. 简单介绍 MongoDB是一个基于分布式文件存储的数据库 由C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。 MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。 它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。 Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数
MongoDB数据库入门到精通看这一篇就够了（免费下载MongoDB中文版可视化工具）
努力让自己发光，对的人才能迎着光而来
05-24 3万+
MongoDB数据库入门到精通看这一篇就够了（免费下载MongoDB中文版可视化工具）
MongoDB快速入门学习
huangjhai的博客
11-28 3086
MongoDB是一个开源、高性能、无模式的文档型数据库，当初的设计就是用于简化开发和方便扩展，是NoSQL数据库产品中的一种。是最像关系型数据库（MySQL）的非关系型数据库。 它支持的数据结构非常松散，是一种类似于JSON 的 格式叫BSON，所以它既可以存储比较复杂的数据类型，又相当的灵活。...
MongoDB 基础 入门到高级进阶详解
starry-sea1412的博客
06-10 322
MongoDB 是一种基于文档的 NoSQL 数据库，数据存储方式采用 BSON（Binary JSON）格式，支持高度可扩展和高可用性。MongoDB 和传统关系型数据库相比，具有非常好的水平扩展能力，简单易用的 API 接口，以及灵活的数据模型设计。
mongodb学习笔记：3. mongodb的基本操作
qq_43672009的博客
09-09 141
图形化工具：Robo 3T。
Mongodb学习资料
09-26
MongoDB数据库基础知识总结 想要学习Mongodb可以作为参考
mongodb学习
09-21
mongodb学习 PPT
MongoDB学习笔记
02-26
MongoDB是一个基于分布式文件存储的数据库开源项目。由C++语言编写，旨在为WEB应用提供可护展的高性能数据存储解决方案。它的特点是可扩展，高性能，易使用，模式自由，存储数据非常方便等。1.1.1主要功能特性a)面向...
五、MongoDB 学习PPT
06-11
MongoDB 学习PPT
深入学习MongoDB---1---入门篇+基础重点篇
wspppdy的博客
04-11 1068
慢查询、journal log（redo log）、oplog。
MongoDB的学习
ungoing的博客
03-31 964
1. MongoDB概述 1. MongoDB是什么? 是一种非关系型数据库（NoSQL）（即not only sql）。 2. 为什么需要学习？ 企业需求 爬取数据到一个量级，使用MongoDB比mysql要好一些。 3. MongoDB的特点 无数据结构（方便爬虫）（没有固定表结构的约束） 高性能（具有非常高的读写能力） 良好支持（有完善的文档，跨平台，稳定） 2. MongoDB的安装 1. 进入官网，选择版本安装（建议安装4.4版本的） MongoDB官网：https://www.mon
MongoDB 学习整理（概念解析）
MR.骑士道
06-09 1136
MongoDB 学习整理（概念解析）
Mongodb学习
weixin_73104281的博客
10-05 492
Mongoose 是一个对象文档模型库，官网。
mongodb 学习
09-05
MongoDB 是一个面向文档的 NoSQL 数据库，适用于存储大量结构化、半结构化和非结构化数据。它支持多种语言，包括 JavaScript、Python、Java、C++ 等。 学习 MongoDB 的步骤： 1. 了解 NoSQL 数据库的概念和特点； 2. 安装 MongoDB，并学会如何启动和关闭数据库； 3. 了解 MongoDB 的基本数据模型，如数据库、集合、文档等； 4. 掌握 MongoDB 的 CRUD 操作（创建、读取、更新、删除）； 5. 学习 MongoDB 的索引、查询、聚合等基本功能； 6. 了解 MongoDB 的高级特性，如分布式、副本集、自动故障转移等。 如果您是初学者，建议从官方文档入手，慢慢学习。如果想要更快地掌握 MongoDB，也可以参加一些在线课程或培训。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值