MongoDB基本原理与使用

最新推荐文章于 2024-04-30 04:15:00 发布

Jafeiyn

最新推荐文章于 2024-04-30 04:15:00 发布

阅读量1.2k

点赞数

文章标签： mongodb 数据库 java

本文链接：https://blog.csdn.net/qq_44528357/article/details/128178744

版权

基本原理

概念

MongoDB是一个以JSON为数据模型的文档型数据库，可以存储海量数据，支持副本、分片等分布式机制，支持动态建模，无固定字段格式

MongoDB与MySQL区别

数据模型角度：MongoDB支持文档模型/关系模型，MySQL只支持关系模型
横向扩展角度：MongoDB支持原生数据分片，MySQL只能依赖第三方插件
索引支持角度：MongoDB底层B+树（低版本B树结构），支持全文索引和地理位置索引，MySQL底层B+树结构
扩展方式角度：MongoDB支持垂直扩展与水平扩展，MySQL只支持垂直扩展（升级机器配置）
高可用角度：MongoDB支持复制集，MySQL支持集群

复制集（主从集群）

在这里插入图片描述

MongoDB复制集类似redis的哨兵模式，主要在于实现服务高可用，同时也实现了数据分发、读写分离、异地容灾等作用

* 复制集功能

数据写入主节点时将数据复制到另一个副本节点（从节点）
主节点发生故障时自动选举出一个新的替代节点

* 复制集结构

一般的复制集由三个或三个以上具有投票权的节点组成，其中一个PRIMARY主节点，两个或多个SECONDARY从节点

* 数据复制

MongoDB复制集间的数据复制类似MySQL主从复制，当一个修改操作（包括插入/更新/删除）到达主节点时，它对数据的操作会被记录到oplog文件中，从节点从主节点上不断获取新进入主节点的oplog，并在自身数据上回放，以此保持跟主节点的数据一致

* 复制集选举

具有投票权的节点之间互相发送心跳，当5次心跳未收到时判断为节点失联，如果失联的是主节点，从节点会发起选举选出新的主节点；如果失联的从节点则不会产生新的选举；选举基于RAFT一致性算法实现，选举成功的必要条件是大多数投票节点存活；一个复制集中最多可以有50个节点，但具有投票权的节点最多7个

* 复制集缺陷

不利于数据管理与维护：集群中只有PRIMARY主节点提供写服务，当写请求或数据量较大时容易出现单机（存储与性能）瓶颈
不支持数据分片

分片集群

在这里插入图片描述

MongoDB分片集群支持数据水平分片到不同服务器节点，突破单机存储与性能瓶颈；
分片集群中的Mongos路由节点可以部署多个组成集群节点，Config配置节点是一个复制集，数据节点则是由多个复制集组成，其中一个复制集即为一个分片；
一般数据量不大并发不高的情况下，建议还是使用复制集架构

特点

应用全透明
数据自动均衡
动态扩容无需下线

角色

路由节点mongos
提供集群单一入口，转发应用请求，选择合适的数据节点进行读写，合并多个数据节点的返回。无状态，建议mongos节点集群部署以提供高可用性。客户请求转发给mongos而不是分片服务器，当查询包含分片片键时，mongos将查询发送到指定分片，否则mongos将查询发送到所有分片，并汇总所有查询结果
配置节点config
就是普通的mongod进程，建议以复制集部署，提供高可用提供集群元数据存储分片数据分布的数据。主节点故障时配置服务器进入只读模式，只读模式下，数据段分裂和集群平衡都不可执行。整个复制集故障时，分片集群不可用
数据节点
以复制集为单位，横向扩展最大1024分片，分片之间数据不重复，所有数据在一起才可以完整工作

分片键

分片键可以是单个字段，也可以是复合字段

范围分片
如key的值从min-max可以把数据进行范围分片，可以排序
hash分片
通过hash(key)进行数据分段，不能排序；片键值用来将集合中的文档划分为数据段，片键必须对应一个索引或索引前缀（单键、复合键），可以使用片键的值或者片键值的哈希值进行分片

选择片键

1.片键值的范围更广（可以使用复合键扩大范围）
2.片键值的分布更平衡（可使用复合片键平衡分布）
3.片键值不要单向增大，减少（可使用哈希片键）

数据段的分裂

当数据段尺寸过大，或者包含过多文档时，触发数据段分裂，只有新增，更新文档时才可能自动触发数据段分裂，数据段分裂通过更新元数据来实现的

集群的平衡

后台运行的平衡器负责监视和调整集群的平衡，当最大和最小分片之间的数据段数量相差过大时触发集群中添加或移除分片时也会触发

单机部署

下载安装包与解压

cd /usr/local
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-4.4.2.tgz
tar -zxvf mongodb-linux-x86_64-rhel70-4.4.2.tgz
mv mongodb-linux-x86_64-rhel70-4.4.2 mongodb-4.4.2
cd mongodb-4.4.2 && ll

在这里插入图片描述

配置环境变量

vi ~/.bashrc

export PATH=$PATH:/usr/local/mongodb-4.4.2/bin

在这里插入图片描述

#按esc保存并退出文件，再按回车即可退出文本编辑界面
:wq

#使环境变量生效
source ~/.bashrc

#创建默认的数据存储目录
mkdir -p /data/db
#创建自定义的数据存储目录
mkdir -p /usr/local/mongodb-4.4.2/data/db
#创建后台启动时的日志输出文件
touch /usr/local/mongodb-4.4.2/data/log.out

在这里插入图片描述

启动MongoDB
mongod [- -fork] [- -dbpath xxx] [- -logpath xxx] [- -bind_ip xxx] [- -auth]
说明：- -fork 表示后台启动，- -dbpath 指定数据存储目录（覆盖默认数据存储目录/data/db），- -logpath 指定日志输出目录（需要配合- -fork使用），- -bind_ip 指定绑定IP（客户端连接时需要指定- -host xxx），- -auth 表示以授权模式启动（客户端连接时需要指定-u xxx）

mongod --fork --bind_ip 192.168.126.136 --dbpath /usr/local/mongodb-4.4.2/data/db --logpath /usr/local/mongodb-4.4.2/data/log.out

在这里插入图片描述

客户端连接验证
mongo [- -host hostname] [- -port port] [-u user]
说明：- -host 表示以指定host连接MongoDB，- -port 表示以指定port连接MongoDB，-u 表示以指定user连接MongoDB

mongo --host 192.168.126.136

创建用户以授权模式启动服务并连接验证

#通过admin库设置密码
use admin
#创建用户
db.createUser({user:“jeffrey”,pwd:“zfy”,roles:[“root”]})
#查看用户
show users
#停止MongoDB服务（注：只能在admin库中使用）
db.shutdownServer()
#退出mongo
exit
（后续通过mongod --auth以授权模式启动服务，通过mongo -u jeffrey输入密码连接服务）

在这里插入图片描述

基本使用

命令操作（Mongo Shell）

通过mongo shell连接进入的是一个js环境，可以使用js相关操作
（说明：以下命令中“$”符号存在显示问题，符号后面已加空格处理，真正执行时需要将后面的空格去掉！！！）

数据库相关操作

#查看数据库
show databases
#创建或使用数据库
use testdb

集合（表）与文档（记录）相关操作

#查看集合
show collections 或 show tables

#创建user集合并插入一条数据（自动生成主键_id）
db.user.insertOne({“name”:“zhangsan”,“age”:18})
#创建user2集合并插入多条数据（自动生成主键_id）
db.user2.insertMany([{“name”:“aaa”,“age”:10},{“name”:“bbb”,“age”:20},{“name”:“ccc”,“age”:30}])
#创建user3集合并插入指定主键_id的一条数据
db.user3.insertOne({“_id”:“1”, “name”:“ddd”,“age”:18})
#往user3集合中插入一条不同字段格式的数据
db.user3.insert({“nickname”:“xiaodidi”})
#往user3集合中插入一条带数组属性的数据
db.user3.insert({“roles”:[“dad”,“mon”,“son”]})
#创建user4集合并插入一条带对象属性的数据
db.user4.insertOne({“name”:“jeffrey”,“tag”:{“sex”:“man”,“hobby”:“game”},“salary”:6666.00,“isDelete”:false})
#创建user5集合并插入复合主键数据（注：复合主键字段顺序改变也会作为不同文档成功插入）
db.user5.insert({_id:{“uid”:1,“ucode”:“A01”},“time”:new Date()})
db.user5.insert({_id:{“ucode”:“A01”,“uid”:1},“time”:new Date()})

#创建user3集合并插入一条数据同时指定安全级别writeConcern及写入有序性ordered
#writeConcern取值：0-写操作不关心是否成功，1-写操作需要被复制到指定节点数才算成功，majority-写操作需要被复制到大多数节点上才算成功（过半机制）
#ordered取值：true-顺序写入，一旦写入操作就会退出，剩余文档不会再写入，false-乱序写入，只要文档能正确写入就行，不关心前面文档是否是错误文档
db.user3.insertOne({“name”:“ddd”,“age”:18},{writeConcern:1,ordered:true})

#查看user集合文档数据
db.user.find()
#查看user2集合文档数据
db.user2.find()
#查看user3集合文档数据
db.user3.find()
#格式化查看user4集合文档数据
db.user4.find().pretty()

#精准等值查询
db.user.find({_id:ObjectId(“638cc595056f36a6ee7ad980”)})

#多条件查询
db.user2.find({name:“aaa”,age:10})

#嵌套对象精准查询
db.user4.find({“tag.sex”:“man”})

#指定返回字段查询（0-不显示字段，1-显示字段，注：默认会显示_id字段，并且只有_id字段可以标识0或1，其他返回字段保持一致，要么同时为0要么同时为1）
db.user4.find({name:“jeffrey”},{_id:0,tag:1})

#逻辑查询and，or，not，nor
db.user2.find({$ and:[{name:“aaa”},{age:10}]}) 或 db.user2.find({name:“aaa”,age:10}) 或 db.user2.find({age:{$ gte:20,$ lte:30}})
db.user2.find({$ or:[{name:“aaa”},{age:20}]})

#查询user2集合中age不小于30的数据（注：其他不包含对应字段的文档也会被查询出来）
db.user2.find({age:{$ not:{$lt: 30}}})

#exists查询
db.user3.find({nickname:{$ exists:true}})

#返回文档游标cursor
db.user2.count()

#skip与limit查询
#跳过游标为1的查询结果
db.user2.find().skip(1)
#跳过游标为1的查询结果并取第一个文档
db.user2.find().skip(1).limit(1)

#统计文档数量（注：count需要指定入参true才能准确统计过滤条件后的文档数量）
db.user2.find().count(true)
db.user2.find().skip(1).count(true)
db.user2.find().skip(1).limit(1).count(true)

#sort排序，入参1表示顺序，-1表示逆序
db.user2.find().sort({age:1})
db.user2.find().sort({age:-1})

#sort, skip, limit结合使用，应用顺序先sort，然后skip，最后limit
db.user2.find().sort({age:-1}).skip(1).limit(1)

#slice返回数据中的一部分数据
db.user3.find({roles:{$ exists:true}},{_id:0,roles:{$ slice:1}})
db.user3.find({roles:{$ exists:true}},{_id:0,roles:{$ slice:2}})
db.user3.find({roles:{$ exists:true}},{_id:0,roles:{$ slice:-1}})
db.user3.find({roles:{$ exists:true}},{_id:0,roles:{$ slice:-2}})

#$ slice:[x,y] 获取跳过x个文档后的y个文档数据，相当于skip,limit
db.user3.find({roles:{$ exists:true}},{_id:0,roles:{$ slice:[1,2]}})

#elemMatch数组元素匹配
db.user3.find({roles:{$ exists:true}},{_id:0,roles:{$ elemMatch:{$ eq:“son”}}})

#updateOne/updateMany更新文档，作用分别为更新一个和更新多个文档
#set 给文档设置字段，无则新增，有则更新
db.user2.updateMany({}, {$ set:{“role”:“user”}})
db.user2.updateMany({}, {$ set:{“role”:“normal”}})

#unset 给文档删除字段
db.user2.updateMany({}, {$ unset:{“role”:“normal”}})

#rename 文档字段重命名
db.user2.updateOne({“age”:10},{$ rename:{“name”:“nickname”}})

#inc 字段值加减，正数表示加，负数表示减
db.user2.updateMany({},{$ inc:{age:10}})

#mul 字段值相乘
db.user2.updateMany({},{$ mul:{age:0.5}})

#max/min 比较取最大值/最小值
db.user2.updateOne({name:“bbb”},{$ max:{age:150}})
db.user2.updateOne({name:“bbb”},{$ min:{age:15}})

#remove删除文档，默认会删除所有满足条件的文档
#justOne:true 只删除一条
db.user5.remove({},{justOne:true})

#drop删除集合所有文档及索引，参数writeConcern值定义了本次删除集合操作的安全写级别
db.user5.drop({},{writeConcern:0})

#删除user集合所有文档，不删除结构与索引（效率较低，建议用drop）
db.user.remove({})

注：主键_id基于时间排序。
#根据ObjectId对象获取不带时区的UTC时间
如：ObjectId(“638cc595056f36a6ee7ad980”).getTimestamp()

UI客户端

下载地址：https//docs.mongodb.com/compass/master/install

在这里插入图片描述

复制集部署

在上述 单机部署 阶段已下载安装完毕MongoDB服务的前提下，由于资源有限，本次部署演示在同一台虚拟机上搭建三个MongoDB节点实例的伪集群（复制集），包含端口不一样的一主两从节点实例

搭建步骤如下：

mkdir -p /usr/local/mongodb-cluster/node1/data/db
mkdir -p /usr/local/mongodb-cluster/node2/data/db
mkdir -p /usr/local/mongodb-cluster/node3/data/db
touch /usr/local/mongodb-cluster/node1/data/mongod.log
touch /usr/local/mongodb-cluster/node2/data/mongod.log
touch /usr/local/mongodb-cluster/node3/data/mongod.log

创建并修改配置文件

mkdir /usr/local/mongodb-cluster/node1/conf /usr/local/mongodb-cluster/node2/conf /usr/local/mongodb-cluster/node3/conf
touch /usr/local/mongodb-cluster/node1/conf/mongod.conf
touch /usr/local/mongodb-cluster/node2/conf/mongod.conf
touch /usr/local/mongodb-cluster/node3/conf/mongod.conf
cd /usr/local/mongodb-cluster && ll

在这里插入图片描述

分别对三个node节点实例下的mongod.conf配置文件进行修改（注：配置文件格式为YAML，下面以node1节点为例，其他节点更改相应数据存储目录与日志文件以及端口号即可，端口号分别为28017，28018，28019）

vi node1/conf/mongod.conf

systemLog:
  #指定系统日志输出位置
  destination: file
  path: /usr/local/mongodb-cluster/node1/data/mongod.log
  #是否追加日志
  logAppend: true
storage:
  #数据存放目录
  dbPath: /usr/local/mongodb-cluster/node1/data/db
net:
  #绑定IP，多个网卡IP用逗号隔开（建议使用内网IP）
  bindIp: 0.0.0.0
  #服务对外暴露的端口
  port: 28017
replication:
  #复制集名称
  replSetName: cluster-rs
processManagement:
  #是否后台启动
  fork: true

#返回并保存退出
:wq

启动集群服务

mongod -f /usr/local/mongodb-cluster/node1/conf/mongod.conf
mongod -f /usr/local/mongodb-cluster/node2/conf/mongod.conf
mongod -f /usr/local/mongodb-cluster/node3/conf/mongod.conf

在这里插入图片描述

验证集群

ps -ef|grep mongod.conf

在这里插入图片描述

客户端随便连接一个mongodb服务，配置复制集

mongo --port 28017

#查看复制集状态

rs.status()

在这里插入图片描述

#添加复制集配置

rs.initiate({
_id:"cluster-rs",
members:[
{
_id:0,
host:"localhost:28017"
},
{
_id:1,
host:"localhost:28018"
},
{
_id:2,
host:"localhost:28019"
}]
})

复制集初始化配置

在这里插入图片描述

再一次查看复制集状态，可以看到28017是PRIMARY主节点，28018和28019两个均是SECONDARY从节点（注意：MongoDB主节点提供读写服务，而从节点默认不提供读服务，需要执行 rs.secondaryOk() 开启读权限才可以）

在这里插入图片描述

分片集群部署

本次模拟搭建两个分片的MongoDB集群，其中路由节点为一个MongoDB实例，配置节点为一个复制集，数据节点为两个复制集组成的分片集群，共计10个MongoDB实例

搭建部署如下：

数据节点（分片节点）

创建第一个分片数据节点的数据目录、日志文件及配置文件（下面以第一个分片sharding1配置为例，第二个分片sharding2数据节点创建类似）

#数据存储目录
mkdir -p /usr/local/mongodb-sharding/datas/sharding1/node1/data/db
mkdir -p /usr/local/mongodb-sharding/datas/sharding1/node2/data/db
mkdir -p /usr/local/mongodb-sharding/datas/sharding1/node3/data/db
#日志输出文件
touch /usr/local/mongodb-sharding/datas/sharding1/node1/data/mongod.log
touch /usr/local/mongodb-sharding/datas/sharding1/node2/data/mongod.log
touch /usr/local/mongodb-sharding/datas/sharding1/node3/data/mongod.log
#配置文件
mkdir /usr/local/mongodb-sharding/datas/sharding1/node1/conf /usr/local/mongodb-sharding/datas/sharding1/node2/conf /usr/local/mongodb-sharding/datas/sharding1/node3/conf
touch /usr/local/mongodb-sharding/datas/sharding1/node1/conf/mongod.conf /usr/local/mongodb-sharding/datas/sharding1/node2/conf/mongod.conf /usr/local/mongodb-sharding/datas/sharding1/node3/conf/mongod.conf

在这里插入图片描述

修改第一个分片数据节点的配置文件（下面以sharding1/node1节点配置为例，其他节点实例配置类似，第一个分片sharding1的复制集名称均为sharding-rs1，端口分别为27010，27011，27012，第二个分片sharding2的复制集名称为sharding-rs2，端口分别为27013，27014，27015）

vi /usr/local/mongodb-sharding/datas/sharding1/node1/conf/mongod.conf

systemLog:
  #指定系统日志输出位置
  destination: file
  path: /usr/local/mongodb-sharding/datas/sharding1/node1/data/mongod.log
  #是否追加日志
  logAppend: true
storage:
  #数据存放目录
  dbPath: /usr/local/mongodb-sharding/datas/sharding1/node1/data/db
net:
  #绑定IP，多个网卡IP用逗号隔开（建议使用内网IP）
  bindIp: 0.0.0.0
  #服务对外暴露的端口
  port: 27010
replication:
  #复制集名称
  replSetName: sharding-rs1
processManagement:
  #是否后台启动
  fork: true

:wq 保存退出

启动数据节点的两个分片复制集MongoDB实例服务

#说明：- -shardsvr表示以分片服务的方式启动
#启动分片1的复制集实例
mongod -f /usr/local/mongodb-sharding/datas/sharding1/node1/conf/mongod.conf --shardsvr
mongod -f /usr/local/mongodb-sharding/datas/sharding1/node2/conf/mongod.conf --shardsvr
mongod -f /usr/local/mongodb-sharding/datas/sharding1/node3/conf/mongod.conf --shardsvr
#启动分片2的复制集实例
mongod -f /usr/local/mongodb-sharding/datas/sharding2/node1/conf/mongod.conf --shardsvr
mongod -f /usr/local/mongodb-sharding/datas/sharding2/node2/conf/mongod.conf --shardsvr
mongod -f /usr/local/mongodb-sharding/datas/sharding2/node3/conf/mongod.conf --shardsvr

mogo客户端配置两个分片的复制集

连接分片1复制集任意实例

mongo --port 27010

rs.initiate({
_id:"sharding-rs1",
members:[
{
_id:0,
host:"localhost:27010"
},
{
_id:1,
host:"localhost:27011"
},
{
_id:2,
host:"localhost:27012"
}]
})

rs.status()

可见分片1复制集的主节点为27010，从节点为27011，27012
在这里插入图片描述

exit 退出

连接分片2复制集任意实例

mongo --port 27013

rs.initiate({
_id:"sharding-rs2",
members:[
{
_id:0,
host:"localhost:27013"
},
{
_id:1,
host:"localhost:27014"
},
{
_id:2,
host:"localhost:27015"
}]
})

rs.status()

可见分片2复制集的主节点为27013，从节点为27014，27015
在这里插入图片描述

exit 退出

配置节点

mkdir -p /usr/local/mongodb-sharding/configs/node1/data/db
mkdir -p /usr/local/mongodb-sharding/configs/node2/data/db
mkdir -p /usr/local/mongodb-sharding/configs/node3/data/db
touch /usr/local/mongodb-sharding/configs/node1/data/mongod.log
touch /usr/local/mongodb-sharding/configs/node2/data/mongod.log
touch /usr/local/mongodb-sharding/configs/node3/data/mongod.log
mkdir /usr/local/mongodb-sharding/configs/node1/conf /usr/local/mongodb-sharding/configs/node2/conf /usr/local/mongodb-sharding/configs/node3/conf
touch /usr/local/mongodb-sharding/configs/node1/conf/mongod.conf /usr/local/mongodb-sharding/configs/node2/conf/mongod.conf /usr/local/mongodb-sharding/configs/node3/conf/mongod.conf

修改配置文件（下面以配置节点复制集node1为例，其他node类似，复制集名称为config-rs，端口分别为27016，27017，27018）

vi /usr/local/mongodb-sharding/configs/node1/conf/mongod.conf

systemLog:
  #指定系统日志输出位置
  destination: file
  path: /usr/local/mongodb-sharding/configs/node1/data/mongod.log
  #是否追加日志
  logAppend: true
storage:
  #数据存放目录
  dbPath: /usr/local/mongodb-sharding/configs/node1/data/db
net:
  #绑定IP，多个网卡IP用逗号隔开（建议使用内网IP）
  bindIp: 0.0.0.0
  #服务对外暴露的端口
  port: 27016
replication:
  #复制集名称
  replSetName: config-rs
processManagement:
  #是否后台启动
  fork: true

:wq 保存退出

启动复制集实例

mongod -f /usr/local/mongodb-sharding/configs/node1/conf/mongod.conf --configsvr
mongod -f /usr/local/mongodb-sharding/configs/node2/conf/mongod.conf --configsvr
mongod -f /usr/local/mongodb-sharding/configs/node3/conf/mongod.conf --configsvr

mongo客户端连接任意实例，配置复制集

mongo --port 27016

rs.initiate({
_id:"config-rs",
members:[
{
_id:0,
host:"localhost:27016"
},
{
_id:1,
host:"localhost:27017"
},
{
_id:2,
host:"localhost:27018"
}]
})

rs.status()

可见配置节点复制集的主节点为27016，从节点为27017，27018
在这里插入图片描述

exit 退出

路由节点

创建路由节点日志文件

mkdir -p /usr/local/mongodb-sharding/mongos/data
touch /usr/local/mongodb-sharding/mongos/data/mongos.log

指定配置节点地址，启动路由节点

mongos --fork --bind_ip 0.0.0.0 --port 27019 --logpath /usr/local/mongodb-sharding/mongos/data/mongos.log --configdb config-rs/192.168.126.138:27016,192.168.126.138:27017,192.168.126.138:27018

查看所有mongo分片集群服务是否都启动OK
在这里插入图片描述

mogo客户端连接路由节点，添加分片

mongo --port 27019

添加分片集群

sh.addShard(“sharding-rs1/localhost:27010,localhost:27011,localhost:27012”)
sh.addShard(“sharding-rs2/localhost:27013,localhost:27014,localhost:27015”)

查看分片状态

sh.status()

在这里插入图片描述

创建分片表（MongoDB的分片是基于集合的，有了分片集群后需要显示分片表，数据才会自动分片）
use order
a. 启用数据库分片
sh.enableSharding(“order”)
b. 添加分片集合
sh.shardCollection(“order.transaction”,{_id:“hashed”})
若添加失败，提示报错：Please create an index that starts with the proposed shard key before sharding the collection
在这里插入图片描述
则需要先确保分片集合建立索引
db.transaction.ensureIndex({_id:“hashed”})

再添加分片集合操作
sh.shardCollection(“order.transaction”,{_id:“hashed”})

到此，创建分片表结束！

下面验证一波：
查看分片状态信息
sh.status()
在这里插入图片描述

查看数据库状态信息
db.stats()
在这里插入图片描述

查看集合是否分片
db.transaction.stats().sharded
在这里插入图片描述

查看集合分片的状态
db.transaction.stats().shards
在这里插入图片描述

查看集合完整状态信息
db.transaction.stats()
在这里插入图片描述

查看集合分片数据分布
db.transaction.getShardDistribution()
在这里插入图片描述

SpringBoot整合MongoDB

引入依赖

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

配置文件

server:
  port: 8080
spring:
  application:
    name: mongodb-demo
---
# mongodb config
spring:
  data:
    mongodb:
      #无账号密码uri
      uri: mongodb://192.168.126.139:27019/order
      #有账号密码uri
#      uri: mongodb://username:password@192.168.126.139:27019/order

测试

package com.itjeffrey.mongodb.test.test;

import com.itjeffrey.mongodb.test.entity.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
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.Component;

import java.util.List;

/**
 * @From: Jeffrey
 * @Date: 2022/12/8
 */
@Component
public class OperationRunner implements ApplicationRunner {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        Transaction transaction = new Transaction("t004", "test spring boot mongodb");
        mongoTemplate.insert(transaction);

        Transaction tran = mongoTemplate.findById(transaction.getId(), Transaction.class);
        System.out.println("inserted data: " + tran);

        Query query = Query.query(Criteria.where("_id").is(tran.getId()));
        Update update = Update.update("tran_id", "t666");
        mongoTemplate.updateFirst(query, update, Transaction.class);
        Transaction transaction1 = mongoTemplate.findOne(query, Transaction.class);
        System.out.println("updated data: " + transaction1);

        mongoTemplate.remove(transaction1);

        List<Transaction> all = mongoTemplate.findAll(Transaction.class);
        System.out.println("------------all transaction-----------");
        for (Transaction t : all) {
            System.out.println(t);
        }

        mongoTemplate.dropCollection(Transaction.class);
        System.out.println("droped collection [transaction]");
    }
}