KWAN的解忧杂货铺

# 一.基础介绍

# 1.什么是 MongoDB?

MongoDB 是一个开源、高性能、无模式的文档型数据库，当初的设计就是用于简化开发和方便扩展，是 NoSQL 数据库产品中的一种。是最

像关系型数据库（MySQL）的非关系型数据库。

它支持的数据结构非常松散，是一种类似于 JSON 的 格式叫 BSON，所以它既可以存储比较复杂的数据类型，又相当的灵活。

MongoDB 中的记录是一个文档，它是一个由字段和值对（fifield:value）组成的数据结构。MongoDB 文档类似于 JSON 对象，即一个文档认

为就是一个对象。字段的数据类型是字符型，它的值除了使用基本的一些类型外，还可以包括其他文档、普通数组和文档数组。

# 2.数据类型

MongoDB 是一种非关系型数据库（NoSQL 数据库），它使用文档存储数据，是目前最流行的 NoSQL 数据库之一。MongoDB 的设计理念是将数据存储为一个文档，而不是存储在表中的行。文档可以包含任何类型的数据，如字符串、数字、日期、数组、嵌入式文档等，这使得 MongoDB 非常适合存储半结构化数据和非结构化数据。

MongoDB 支持多种数据类型，包括文档、网格文件、地理空间索引等，这些功能使得 MongoDB 在处理海量数据和实时数据分析方面具有很强的优势。此外，MongoDB 的数据模型非常灵活，可以根据应用程序的需要进行快速更改，而不需要进行复杂的数据迁移和升级。同时，MongoDB 也支持分布式部署，可以通过水平扩展来提高性能和容错性。

# 3.查询

MongoDB 的查询语言非常强大，支持复杂的查询操作，包括聚合、分组、排序、分页等。MongoDB 也提供了丰富的工具和 API，方便开发人员进行数据管理和应用程序开发。例如，它提供了 Mongo Shell、MongoDB Compass 等工具，可以方便地进行数据导入、导出、备份和恢复等操作。 总的来说，MongoDB 是一种高性能、高可扩展性、高可用性的 NoSQL 数据库，广泛应用于 Web 应用程序、大数据分析、云计算等领域。

# 4.业务应用场景

传统的关系型数据库（如 MySQL），在数据操作的“三高”需求以及应对 Web2.0 的网站需求面前，显得力不从心。

“三高”需求：

• High performance - 对数据库高并发读写的需求。

• Huge Storage - 对海量数据的高效率存储和访问的需求。

• High Scalability && High Availability- 对数据库的高可扩展性和高可用性的需求。

而 MongoDB 可应对“三高”需求。

# 5.具体场景

1）社交场景，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能。

2）游戏场景，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、高效率存储和访问。

3）物流场景，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将

订单所有的变更读取出来。

4）物联网场景，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析。

5）视频直播，使用 MongoDB 存储用户信息、点赞互动信息等。

这些应用场景中，数据操作方面的共同特点是：

（1）数据量大

（2）写入操作频繁（读写都很频繁）

（3）价值较低的数据，对事务性要求不高

对于这样的数据，我们更适合使用 MongoDB 来实现数据的存储。

# 6.什么时候选择 MongoDB

在架构选型上，除了上述的三个特点外，如果你还犹豫是否要选择它？可以考虑以下的一些问题：

应用不需要事务及复杂 join 支持

新应用，需求会变，数据模型无法确定，想快速迭代开发

应用需要 2000-3000 以上的读写 QPS（更高也可以）

应用需要 TB 甚至 PB 级别数据存储

应用发展迅速，需要能快速水平扩展

应用要求存储的数据不丢失

应用需要 99.999%高可用

应用需要大量的地理位置查询、文本查询

如果上述有 1 个符合，可以考虑 MongoDB，2 个及以上的符合，选择 MongoDB 绝不会后悔。

# 7.对比 mysql

image-20230715004341057

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

# 8.数据模型

MongoDB 的最小存储单位就是文档(document)对象。文档(document)对象对应于关系型数据库的行。数据在 MongoDB 中以

BSON（Binary-JSON）文档的格式存储在磁盘上。

BSON（Binary Serialized Document Format）是一种类 json 的一种二进制形式的存储格式，简称 Binary JSON。BSON 和 JSON 一样，支持

内嵌的文档对象和数组对象，但是 BSON 有 JSON 没有的一些数据类型，如 Date 和 BinData 类型。

BSON 采用了类似于 C 语言结构体的名称、对表示方法，支持内嵌的文档对象和数组对象，具有轻量性、可遍历性、高效性的三个特点，可

以有效描述非结构化数据和结构化数据。这种格式的优点是灵活性高，但它的缺点是空间利用率不是很理想。

Bson 中，除了基本的 JSON 类型：string,integer,boolean,double,null,array 和 object，mongo 还使用了特殊的数据类型。这些类型包括

date,object id,binary data,regular expression 和 code。每一个驱动都以特定语言的方式实现了这些类型，查看你的驱动的文档来获取详

细信息。

# 9.BSON 数据类型

image-20230715004739169

提示:shell 默认使用 64 位浮点型数值。{“x”：3.14}或{“x”：3}。对于整型值，可以使用 NumberInt（4 字节符号整数）或 NumberLong（8 字节符号整数），{“x”:NumberInt(“3”)}{“x”:NumberLong(“3”)}

# 10.MongoDB 特点

（1）高性能：

MongoDB 提供高性能的数据持久性。特别是,

对嵌入式数据模型的支持减少了数据库系统上的 I/O 活动。

索引支持更快的查询，并且可以包含来自嵌入式文档和数组的键。（文本索引解决搜索的需求、TTL 索引解决历史数据自动过期的需求、地

理位置索引可用于构建各种 O2O 应用）

mmapv1、wiredtiger、mongorocks（rocksdb）、in-memory 等多引擎支持满足各种场景需求。

Gridfs 解决文件存储的需求。

（2）高可用性：

MongoDB 的复制工具称为副本集（replica set），它可提供自动故障转移和数据冗余。

（3）高扩展性：

MongoDB 提供了水平可扩展性作为其核心功能的一部分。

分片将数据分布在一组集群的机器上。（海量数据存储，服务能力水平扩展）

从 3.4 开始，MongoDB 支持基于片键创建数据区域。在一个平衡的集群中，MongoDB 将一个区域所覆盖的读写只定向到该区域内的那些

片。

（4）丰富的查询支持：

MongoDB 支持丰富的查询语言，支持读和写操作(CRUD)，比如数据聚合、文本搜索和地理空间查询等。

（5）其他特点：如无模式（动态模式）、灵活的文档模型、

# 二.单机部署

# 1.下载安装包

MongoDB 提供了可用于 32 位和 64 位系统的预编译二进制包，你可以从 MongoDB 官网下载安装，MongoDB 预编译二进制包下载地址：

下载地址 (opens new window)

image-20230715005124493

MongoDB 的版本命名规范如：x.y.z；

y 为奇数时表示当前版本为开发版，如：1.5.2、4.1.13；

y 为偶数时表示当前版本为稳定版，如：1.6.3、4.0.10；

z 是修正版本号，数字越大越好。

# 2.解压安装

将压缩包解压到一个目录中。

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

#到指定目录
cd /usr/local

#创建文件夹
mkdir mongodb

#上传文件
scp /Users/qinyingjie/Downloads/mongodb-linux-x86_64-4.0.10.tgz root@43.139.90.182:/usr/local/mongodb

#解压
tar -xvf mongodb-linux-x86_64-4.0.10.tgz

#删除压缩包
rm mongodb-linux-x86_64-4.0.10.tgz
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 3.日志目录

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

#日志存储目录
mkdir -p /mongodb/single/log
1
2
3
4
5

# 4.修改配置

vi /mongodb/single/mongod.conf
1
systemLog:
    destination: file
    path: "/mongodb/single/log/mongod.log"
    logAppend: true
storage:
    dbPath: "/mongodb/single/data/db"
    journal:
        enabled: true
processManagement:
    fork: true
net:
    bindIp: localhost,172.22.30.207
    port: 27017
1
2
3
4
5
6
7
8
9
10
11
12
13

# 5.启动验证

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

#启动
/usr/local/mongodb/mongodb-linux-x86_64-4.0.10/bin/mongod -f /mongodb/single/mongod.conf

#验证
ps -ef |grep mongod

#退出
exit
1
2
3
4
5
6
7
8

# 6.shell 登录

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

#进入到bin目录
cd /usr/local/mongodb/mongodb-linux-x86_64-4.0.10/bin

#客户端进入
./mongo --host=127.0.0.1 --port=27017

#js的语法，因为mongo的shell是一个JavaScript的shell
1
2
3
4
5
6
7

# 7.快速关闭服务

#通过进程编号关闭节点
kill -2 54410
1
2

# 8.修复数据

#删除lock文件
rm -f /mongodb/single/data/db/*.lock

#修复数据
/usr/local/mongdb/bin/mongod --repair --dbpath=/mongodb/single/data/db
1
2
3
4
5

# 9.标准关闭

#客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行。
mongo --port 27017

#切换到admin库
use admin

#关闭服务
db.shutdownServer()
1
2
3
4
5
6
7
8

# 10.图形化客户端

到 MongoDB 官网下载 MongoDB Compass，

地址：https://www.mongodb.com/download-center/v2/compass?initial=true

如果是下载安装版，则按照步骤安装；如果是下载加压缩版，直接解压，执行里面的 MongoDBCompassCommunity.exe 文件即可。

在打开的界面中，输入主机地址、端口等相关信息，点击连接：

image-20230715005655089

# 三.增删改查

# 1.api 汇总

选择切换数据库：use articledb
插入数据：db.comment.insert({bson数据})
查询所有数据：db.comment.find();
条件查询数据：db.comment.find({条件})
查询符合条件的第一条记录：db.comment.findOne({条件})
查询符合条件的前几条记录：db.comment.find({条件}).limit(条数)
查询符合条件的跳过的记录：db.comment.find({条件}).skip(条数)
修改数据：db.comment.update({条件},{修改后的数据}) 或db.comment.update({条件},{$set:{要修改部分的字段:数据})
修改数据并自增某字段值：db.comment.update({条件},{$inc:{自增的字段:步进值}})
删除数据：db.comment.remove({条件}) 统计查询：db.comment.count({条件})
模糊查询：db.comment.find({字段名:/正则表达式/})
条件比较运算：db.comment.find({字段名:{$gt:值}})
包含查询：db.comment.find({字段名:{$in:[值1，值2]}})或db.comment.find({字段名:{$nin:[值1，值2]}})
条件连接查询：db.comment.find({$and:[{条件1},{条件2}]})或db.comment.find({$or:[{条件1},{条件2}]})
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 2.数据库语法

注意: 在 MongoDB 中，集合只有在内容插入后才会创建! 就是说，创建集合(数据表)后要再插入一个文档(记录)，集合才会真正创建。

#选择数据库,不存在则创建
use 数据库名称
use articledb

#查看数据库,创建集合了才显示之前创建的db
show dbs
show databases

#查看当前正在使用的数据库
db

#删除数据库
db.dropDatabase()
1
2
3
4
5
6
7
8
9
10
11
12
13

MongoDB 中默认的数据库为 test，如果你没有选择数据库，集合将存放在 test 数据库中。

默认数据库

admin:从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。

local:这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合

confifig:当 Mongo 用于分片设置时，confifig 数据库在内部使用，用于保存分片的相关信息。

# 3.集合

#创建集合
db.createCollection(name)
db.createCollection("mycollection")

#查看集合
show collections
show tables

#集合删除
db.collection.drop()
db.集合.drop()
1
2
3
4
5
6
7
8
9
10
11
  • 集合的命名规范：
  • 集合名不能是空字符串""。
  • 集合名不能含有\0 字符（空字符)，这个字符表示集合名的结尾。
  • 集合名不能以"system."开头，这是为系统集合保留的前缀。
  • 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。

# 4.集合的隐式创建

当向一个集合中插入一个文档的时候，如果集合不存在，则会自动创建集合。

提示：通常我们使用隐式创建文档即可。

# 5.文档格式

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

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

# 6.单个文档插入

使用 insert() 或 save() 方法向集合中插入文档，语法如下：

db.collection.insert(
	<document or array of documents>,
	{
		writeConcern: <document>,
		ordered: <boolean>
	}
)
1
2
3
4
5
6
7

示例

要向 comment 的集合(表)中插入一条测试数据：

默认会插入一个主键

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

image-20230715110047615

提示：

  1. comment 集合如果不存在，则会隐式创建
  2. mongo 中的数字，默认情况下是 double 类型，如果要存整型，必须使用函数 NumberInt(整型数字)，否则取出来就有问题了。
  3. 插入当前日期使用 new Date()
  4. 插入的数据没有指定 _id ，会自动生成主键值
  5. 如果某字段没值，可以赋值为 null，或不写该字段。
#执行后，如下，说明插入一个数据成功了
WriteResult({ "nInserted" : 1 })
1
2

# 7.批量插入

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

image-20230715105958951

# 8.文档查询

#.查询所有
db.comment.find()
db.comment.find({})

#带条件查询
db.comment.find({userid:'1003'})

#查询一条
db.comment.findOne({userid:'1003'})

#投影查询,默认会显示id
db.comment.find({userid:"1003"},{userid:1,nickname:1})

#不显示id
db.comment.find({userid:"1003"},{userid:1,nickname:1,_id:0})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

image-20230715110131314

# 9.文档更新

#覆盖更新
db.comment.update({_id:"1"},{likenum:NumberInt(1001)})

#局部修改
db.comment.update({_id:"2"},{$set:{likenum:NumberInt(889)}})

#批量修改
//默认只修改第一条数据
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒2"}})

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

#列值加1
db.comment.update({_id:"3"},{$inc:{likenum:NumberInt(1)}})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

image-20230715110210078

# 10.删除文档

#全部删除
db.comment.remove({})

#部分删除
db.comment.remove({_id:"1"})
1
2
3
4
5

# 11.count 查询

#统计所有记录数
db.comment.count()

#按条件统计
db.comment.count({userid:"1003"})
1
2
3
4
5

# 12.分页查询

#取三条
db.comment.find().limit(3)

#前3个不要
db.comment.find().skip(3)

#分页
#第一页
db.comment.find().skip(0).limit(2)
#第二页
db.comment.find().skip(2).limit(2)
#第三页
db.comment.find().skip(4).limit(2)
1
2
3
4
5
6
7
8
9
10
11
12
13

# 13.排序查询

#对userid降序排列，并对访问量进行升序排列
db.comment.find().sort({userid:-1,likenum:1})
1
2

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

# 14.正则查询

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

#专家开头
db.comment.find({content:/^专家/})
1
2
3
4
5

image-20230715110431660

# 15.比较查询

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
1
2
3
4
5
#大于
db.comment.find({likenum:{$gt:NumberInt(700)}})
1
2

# 16.包含查询

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

#不在
db.comment.find({userid:{$nin:["1003","1004"]}})
1
2
3
4
5

# 17.条件连接

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

#or
db.comment.find({$or:[ {userid:"1003"} ,{likenum:{$lt:1000} }]})
1
2
3
4
5

# 四.索引 index

# 1.概述

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

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

常致命的。

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

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

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

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

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

# 2.单字段索引

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

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

# 3.复合索引

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

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

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

image-20230715020112680

# 4.其他索引

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

地理空间索引（Geospatial Index）

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

几何的二维球面索引。

文本索引（Text Indexes）

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

而将集合中的词作为词干，只存储根词。

哈希索引（Hashed Indexes）

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

持相等匹配，不支持基于范围的查询。

# 5.索引的 api

#获取索引
db.comment.getIndexes()

#创建索引
db.comment.createIndex({userid:1})

#创建复合索引
db.comment.createIndex({userid:1,nickname:-1})

#移除索引
db.comment.dropIndex({userid:1})

#删除所有索引
db.collection.dropIndexes()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

image-20230715110647863

# 6.索引的使用

#查看执行计划
db.comment.find({userid:"1003"}).explain()
1
2

image-20230715110718148

关键点看："stage"："IXSCAN"，表示全集合扫描

# 五.文章评论

# 1.文档说明

官方 api (opens new window)

存放文章评论的数据存放到 MongoDB 中，数据结构参考如下：

数据库：articledb

专栏文章评论 comment
字段名称 字段含义 字段类型 备注
_id ID Objectld 或 String Mongo 的主键的字段
articleid 文章 ID String
content 评论内容 String
userid 评论人 ID String
nickname 评论人昵称 String
createdatetime 评论的日期时间 Date
likenum 点赞数 Int32
replynum 回复数 Int32
state 状态 String 0：不可见；1：可见；
parentid 上级 ID String 如果为 0 表示文章的顶级评论

# 2.pom

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.28</version>
</dependency>
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.27</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 3.application

spring:
  #数据源配置
  data:
    mongodb:
      # 主机地址
      host: 43.139.90.182
      # 数据库
      database: articledb
      # 默认端口是27017
      port: 27017
      #也可以使用uri连接
#      uri: mongodb://bobo:123456@43.139.90.182:27017/articledb?connect=replicaSet&slaveOk=true&replicaSet=myrs
#      uri: mongodb://bobo:123456@180.76.159.126:27017,180.76.159.126:27018,180.76.159.126:27019/articledb?connect=replicaSet&slaveOk=true&replicaSet=myrs
1
2
3
4
5
6
7
8
9
10
11
12
13

# 4.service

package cn.itcast.article.service;

import cn.itcast.article.dao.CommentRepository;
import cn.itcast.article.po.Comment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class CommentService {
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private CommentRepository commentRepository;

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

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

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

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

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

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

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

    public Page<Comment> findByUseridAndLikenum(String userid, int likenum, int page, int size) {
        return commentRepository.findByUseridAndLikenum(userid, likenum, PageRequest.of(page - 1, size));
    }

    public Page<Comment> findByUseridContainingAndLikenumGreaterThanEqual(String userid, int likenum, int page, int size) {
        return commentRepository.findByUseridContainingAndLikenumGreaterThanEqual(userid, likenum, PageRequest.of(page - 1, size));
    }

    public List<Comment> findByUseridAndLikenum(String userid, int likenum) {
        return commentRepository.findByUseridAndLikenum(userid, likenum);
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

# 5.实体

package cn.itcast.article.po;

import lombok.Data;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Date;


/**
 * 把一个java类声明为mongodb的文档，可以通过collection参数指定这个类对应的文档。
 *
 * @author : qinyingjie
 * @version : 2.2.0
 * @Document(collection="mongodb 对应 collection 名")
 * 若未加 @Document ，该 bean save 到 mongo 的 comment collection
 * 若添加 @Document ，则 save 到 comment collection
 * 文章评论实体类
 * @date : 2023/7/15 11:14
 */

@Data
@Document(collection = "comment")//可以省略，如果省略，则默认使用类名小写映射集合
//复合索引
@CompoundIndex(def = "{'userid': 1, 'nickname': -1}")
public class Comment implements Serializable {
    /**
     * 主键标识，该属性的值会自动对应mongodb的主键字段"_id"，如果该属性名就叫“id”,则该注解可以省略，否则必须写
     */
    private String id;
    /**
     * 吐槽内容
     */
    @Field("content")
    private String content;
    /**
     * 发布日期
     */
    private Date publishtime;
    /**
     * 添加了一个单字段的索引 发布人ID
     */
    @Indexed
    private String userid;

    /**
     * 昵称
     */
    private String nickname;
    /**
     * 评论的日期时间
     */
    private LocalDateTime createdatetime;
    /**
     * 点赞数
     */
    private Integer likenum;
    /**
     * 回复数
     */
    private Integer replynum;
    /**
     * 状态
     */
    private String state;
    /**
     * 上级ID
     */
    private String parentid;
    /**
     * 文章id
     */
    private String articleid;
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# 6.dao

package cn.itcast.article.dao;

import cn.itcast.article.po.Comment;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;

import java.util.List;

public interface CommentRepository extends MongoRepository<Comment, String> {
    /**
     * findByUserid的Userid一定要和参数一致
     *
     * @param userid
     * @param pageable
     * @return
     */
    Page<Comment> findByUserid(String userid, Pageable pageable);

    /**
     * 多字段查询
     *
     * @param userid
     * @param likenum
     * @param pageable
     * @return
     */
    Page<Comment> findByUseridAndLikenum(String userid, Integer likenum, Pageable pageable);

    /**
     * 查询userid固定值,并且likenum大于等于的文档
     *
     * @param userid
     * @param likenum
     * @param pageable
     * @return
     */
    Page<Comment> findByUseridContainingAndLikenumGreaterThanEqual(String userid, Integer likenum, Pageable pageable);


    /**
     * 正则查询
     * 使用了@Query注解来指定查询语句。在查询语句中，
     * 使用了$regex操作符表示name匹配正则表达式，使用了$options选项表示不区分大小写，使用了$gte操作符表示age大于等于指定值。
     *
     * @param userid
     * @param likenum
     * @return
     */
    @Query("{ 'userid' : { $regex: ?0, $options: 'i' }, 'likenum' : { $gte: ?1 } }")
    List<Comment> findByUseridAndLikenum(String userid, Integer likenum);
}
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
46
47
48
49
50
51
52
53

# 7.多字段查询

在 MongoDB 中，可以使用$and操作符将多个查询条件组合在一起，实现多字段查询。以下是一个使用 Spring Data MongoDB 的 MongoRepository 进行多字段查询的例子：

假设有一个名为User的 MongoDB 集合，其中每个文档包含name和age两个字段。要根据name和age进行查询，可以创建一个UserRepository接口，并继承MongoRepository接口，如下所示：

public interface UserRepository extends MongoRepository<User, String> {
    List<User> findByNameAndAge(String name, int age);
}
1
2
3

在UserRepository接口中，定义了一个findByNameAndAge方法，用来根据name和age进行查询。这个方法返回一个List<User>，包含符合条件的所有用户。

在这个方法中，我们使用了 Spring Data MongoDB 提供的方法命名规则，将方法名中的name和age解析成查询条件。具体来说，它会自动将方法名转换为 MongoDB 的查询语句，如下所示：

{ "name" : "John", "age" : 30 }
1

这个查询语句表示查找name为John且age为30的所有文档。

# 8.大于查询

如果需要更复杂的查询条件，可以在方法名中使用其他的操作符。例如，以下方法名表示查找name包含John且age大于等于30的所有文档：

List<User> findByNameContainingAndAgeGreaterThanEqual(String name, int age);
1

在这个方法名中，使用了Containing操作符表示name包含John，使用了GreaterThanEqual操作符表示age大于等于30。

# 9.正则查询

需要注意的是，Spring Data MongoDB 提供的方法命名规则并不是万能的，如果需要更复杂的查询条件，可以使用@Query注解，手动编写查询语句。例如：

@Query("{ 'name' : { $regex: ?0, $options: 'i' }, 'age' : { $gte: ?1 } }")
List<User> findByNameAndAge(String name, int age);
1
2

在这个例子中，使用了@Query注解来指定查询语句。在查询语句中，使用了$regex操作符表示name匹配正则表达式，使用了$options选项表示不区分大小写，使用了$gte操作符表示age大于等于指定值。

上次更新: 10/29/2024, 10:27:50 AM

← 08-MongoDB进阶 →