前言
- mongoDB引言
1.1 mongo概述
1.2 集群与分布式梳理 - mongodb与关系型数据库对比 + mongodb特点
- Linux系统安装MongoDB
- mongodb中的常用指令
- mongodb中的查询基本使用
- java集成mongodb
6.1 实战一：Java操作mongoDB
6.2 实战二：Springboot操作mongoDB - mongodb阶段小结
前言
本章节主要讲解mongoDB的初步讲解，主要讲解的几点内容如下所示：
1.通过mnongoDB的基本概念，说明mongoDB为什么被称为"分布式>存储数据库"。
2.分布式与集群
3.mongoDB命令
4.Java集成mongoDB。
1、mongoDB引言
1.1 mongo概述
1. mongodb 是一个基于文档型的数据库；而redis是一个基于内存型的
数据库。
2. 我们将mongodb称为"分布式存储数据库"的原因？
⑴ 原因一：一般来讲我们平时在项目中使用'mongodb',若仅部署一个
mongodb通常是无法满足项目开发过程中的需求的，因此需要部署多台以此来
启动mongodb实例，并最后以此组成最终确实可以组成mongodb的集群。
--->但是又是为什么我们将mongodb称为分布式呢？原因就是mongodb中
存储的是'集合'的概念，我们是基于mongodb的这种存储特性去对其做拆分
的。我们一般在搭建mongodb集群并不是在每一个mongodb中去存储相同的数
据，而是将原来一个集合中的数据分别存储到多个mongodb中去，而日后
我去mongodb查询数据时会将这多个mongodb节点中的数据做一个汇总并
将最终的结果返回响应出去。
⑵ 原因二：对于存储一个完整的数据我们利用mongodb是将这个完整数据分别
往不同的mongodb的节点中去存储的，因此后续若想要获取到完整的数据则必须
对所有的mongodb节点做整合(汇总)才可以获取到一个最终的完整数据，因此基于
上面说的在每一个mongodb节点中存储不同的数据的这个概念来讲所以我们才将
mongodb称为"分布式存储数据库"。
⑶ 原因三：拿redis来讲对于redis：我们管它叫内存型数据库，同时也管
它叫'分布式缓存服务器'。我们搭建完redis集群之后，发现redis集群
的每一个节点里面存储的都不是一样的数据，再拿mencache来讲对于我们也
将其称为'分布式缓存服务器'，是因为mencache的每一个节点中存储的也不是
相同的数据。
1.2 集群与分布式梳理
1. 什么是集群
⑴ 多个节点干相同的事情
⑵ 生活小栗子: 赛龙舟中每个划桨的人都是一个节点, 每个节点做相同的事情,
这就是集群.
2. 什么是分布式
⑴ 多个节点协同完成一件事情, 每个节点做不同的事情.
⑵ 生活例子: 演出的一整个乐队中有的人弹吉他, 有的人打鼓, 有的人
吹小号. 并且共同完成一次演出, 这就是分布式.
3. 集群与分布式
⑴ 不管在生活中, 还是在我们的实际项目中, 集群与分布式大多都是同时出现的。
⑵ 生活例子: 龙舟比赛中划桨的人, 与打鼓的, 人与掌舵的人分别做不同的事情, 却共同完成赛龙舟这件事情, 这就是分布式. 同时划桨的多个人做着相同的事情, 这就是集群. 可见分布式与集群是同时出现的.
4. 集群&分布式
⑴ 集群：完成同一个工作，创建多个tomcat服务器来承担现有系统的并发压力。
多个tomcat就称为集群。
⑵ 分布式：
➀ 早期：所有业务都是写在同一个项目中的。之后我们会将一个完
整的项目部署到"tomcat应用服务器1"或者将项目部署到"tomcat应
用服务器2"上或者部署到"tomcat3"上
--->此时我们将此项目完整的部署到每一个tomcat应用服务器上，
我们管这个项目实际上是运行在集群这样的系统里面。
➁ 现在：如果要将一个完整项目业务剥离出来。就类似将一个项目
拆分成-->订单业务系统，产品业务系统，用户业务系统...等等独
立的一个个单一项目业务并实现部署时也是需要部署到多台tomcat
应用服务器的。
a. '商品业务系统'部署到多个tomcat应用服务器上
(tomcat1，tomcat2，tomcat3)。
b. '产品业务系统'也部署到多个tomcat应用服务器上
(tomcat4，tomcat5，tomcat6)。
c. '用户业务系统'也部署到多个tomcat应用服务器上
(tomcat7，tomcat8)。
.....
--->这样的搭建方式是要通过多个tomcat应用服务器配合完成部
署的，对于实现这一过程的系统我们就管它叫做'分布式系统'。
5. 站在'分布式架构'和'项目'角度分析
⑴ 站在整个分布式的架构里面，我们可以对它定义为：针对于同一种功
能(同一tomcat有多个)来讲我们可以管它叫集群。那么如果我们这个系统
既用了tomcat集群，又用了mysql集群我们就可以说我们的系统是'分布
式系统'。(因为tomcat和mysql它们所干的事情是不一样的)
⑵ 站在项目的层面上讲，将项目部署到多个tomcat应用服务器上，这个
项目实际上就是部署在集群的系统里面。日后如果将项目中独立拆分出一
个个完整的业务系统，每个业务系统都要部署到多个tomcat应用服务器
中-->日后我们管整个项目也称为'分布式系统'。
2. mongodb与关系型数据库对比 + mongodb特点
1. 关系型数据库(比如：mysql)
⑴ 对于mysql来讲"存储数据的顺序为"：库-->表-->存字段数据 -->以
这种方式来存储数据。
⑵ 对于mongodb来讲"存储数据的顺序为"：库-->集合(类似mysql中的
表)-->存json数据
⑶ 但是在整个'mongodb'中它是没有事务的概念的。如果我们对于数据
的原子性要求非常高的话就需要慎重考虑是否真的要去使用'mongodb'。
➀ 在使用'mongodb'过程中，当发现少一个字段时我们可以直接对其
添加一个字段并赋值，当发现某个字段不需要时也可以直接动态的去
删除不需要的字段。但是'mongodb'并不能替代我们项目中的关系型
数据库(mysql)，因为本身mongodb是没有'事务'的概念的，因此对
于数据'原子性'要求很高的话，则建议去使用'关系型数据库'去存储
数据。
--->因此在项目开发过程中，我们一般使用'mongodb'去配合关系型
数据库(mysql)同时使用的。
➁ mongodb支持的数据结构非常松散，是类似json的bson格式，因
此可以存储比较复杂的数据类型。
➂ mongodb的出现也确实减少了开发阶段'库表设计阶段'的时间。
2. mongodb特点
⑴ 面向集合存储，易存储对象类型的数据
⑵ 支持查询,以及动态查询
⑶ 支持RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言
⑷ 文件存储格式为BSON（一种JSON的扩展）
⑸ 支持复制和故障恢复和分片
3. Linux系统安装MongoDB
1. 百度搜索安装mongodb地址：
https://blog.csdn.net/dong0928/article/details/105197356
2. Linux下载安装MongoDB
⑴ 第一：将下载好的'mongodb-linux-x86_64-4.0.13.tgz'拉取到Linux系统中，并进行解压。
➀ 解压mongodb
[root@localhost ~]# tar -zxvf mongodb-linux-x86_64-4.0.13.tgz
➁ 将mongodb解压后生成的mongodb文件重命名
[root@localhost ~]# ll
总用量 83228
drwxr-xr-x. 3 root root 135 10月 13 09:37 mongodb-linux-x86_64-4.0.13
-rw-r--r--. 1 root root 85223276 10月 13 09:34 mongodb-linux-x86_64-4.0.13.tgz
drwxr-xr-x. 2 root root 211 10月 13 09:36 soft
[root@localhost ~]# mv mongodb-linux-x86_64-4.0.13 mongo
➂ 进入mongoDB 的包下，可以查看它里面的'/bin'目录里面存放了
mongodb启动的一些脚本文件。
▲. mongodb作为一个nosql的产品，此数据库简单易用，简单到连配
置文件都没有
▲. 要操作执行mongodb里面的可执行文件直接进入'/bin'目录里面
去执行即可。
--->对于解压后的mongodb.tgz如果想去使用它，我们直接使用即
可。
➃ 启动mongodb 命令
a. 进入/bin目录
[root@localhost ~]# cd mongo
[root@localhost mongo]# cd bin/
[root@localhost bin]# ls
bsondump mongod mongofiles mongorestore mongotop
install_compass mongodump mongoimport mongos
mongo mongoexport mongoreplay mongostat
b. 启动mongodb(若要启动mongodb，会用到/bin下
的'mongod'这个命令，此命令是用来启动mongodb服务的)。
# 在Linux系统中创建存储mongodb数据的文件夹(/data 目
录)
[root@localhost ~]# pwd
/root
[root@localhost ~]# mkdir data
# 启动mongodb，指定启动的默认端口号(27017)，以及指定
mongodb数据的存储位置为根目录下的'/data目录'
[root@localhost ~]# cd mongo
[root@localhost mongo]# cd bin/
[root@localhost bin]# ./mongod --port 27017 --dbpath=/root/data/
----->这里的"/root/data/"是我们创建用来存储mongodb数
据的目录位置。
---->启动mongodb中出现"[initandlisten] waiting for
connections on port 27017"
(这句话意思：mongodb在等待客户端连接)说明mongodb服务已
经启动成功。
⑵ 第二：通过mongodb的客户端去连接启动后的'mongodb服务'。
在mongodb的/bin目录下，有一个客户端启动的指令(就类似在cmd
中执行mysql连接mysql服务)
a. 进入mongo/bin
[root@localhost ~]# cd mongo
[root@localhost mongo]# cd bin/
[root@localhost bin]# ls
bsondump mongod mongofiles mongorestore mongotop
install_compass mongodump mongoimport mongos
mongo mongoexport mongoreplay mongostat
b. 使用客户端指令去链接mongodb服务(默认连接端口为27017，默
认连接的IP地址为localhost)，因此无需我们手动去指定连接的IP
地址和端口号。
[root@localhost bin]# ./mongo
------------------------------------------------------------------------------------
3. mongodb 安装使用小结
⑴ 启动mongodb(进入mongodb的bin目录执行启动指令)，指定启动端口和mongodb数据存放路径
./mongod --port=27017 --dbpath=/root/data
⑵ 客户端连接mongodb服务
./mongo --port 27017
⑶ 客户端连接'mongodb服务后'的基本操作命令
➀ 指令一：在mongodb数据库中也有一个一个'库'的概念：查看
mongodb中的所有库
show databases;
➁ 指令二：使用一个库(选中一个库)
use 库名;
➂ 指令三：查看当前所在的库
db;
➃ 指令四：若想自己创建一个mongodb的'库'，在mongodb中不存在
创建'库'的指令。你直接使用一个不存在的'库'就表示创建一个数据
库。use 随便输入一个库名(比如：testDB);
--->执行完此指令后就会在创建完'testDB'库后，自动切换
到'tetsDB数据库'。
◆. 注意：对于刚创建的'testDB'数据库，我们使用'show
databases'查看当前所有数据库，不会显示出我们刚创建的数据
库'testDB',因为mongoDB中不会显示库没有集合的库
➄ 指令五：查看当前库中有哪些集合的指令
◆. MongoDB的库中存储的是一个一个的集合，因此可以去查看
mongodb中存储的集合并集合存储到mongodb中。
a. 查看当前库中有哪些集合
show collections; 或者 show tables;--->两个指令均可
b. 创建集合(collection)-->在mongodb相当于关系型数据库
(mysql)中的表db.createCollection("创建的集合名");
4. mongodb中的常用指令
1. mongodb的相关指令
⑴ 查看库：show databases/dbs;
⑵ 使用库：use 库名 -->库不存在则创建并切换，库存在直接切换到当前库。
⑶ 查询当前使用库：db
⑷ 删除一个库：db.dropDatabase();
# 删除一个库之前需要先进入要删除的库，在执行删除指令
➀ 切换到使用的库下：use ems;
➁ 执行删除ems数据库指令：db.dropdatabase();
➂ 查看'mongodb'下是否还存在'ems库'：show dbs;
⑸ 查看所有mongodb的指令(帮助指令)：db.help();
--------------------------------------------------------
2. mongodb中的集合(collection)的相关指令
⑴ 创建一个集合(两种方式)
➀ 方式一：显示创建--->db.createCollection("集合名称");
> use ems; #进入ems数据库
> db.createCollection("t_user"); #显示创建t_user集合
> show collections; #查看集合t_user是否创建成功
➁ 方式二：隐式创建
> use ems; #进入ems数据库
> db.t_emp.insert({"name":"zhangsan"}) #显示创建t_emp集
合并插入一条记录
> show collections; #查看集合t_emp是否创建成功
⑵ 查询库中存在那些集合：
> use ems; #进入ems数据库
> show collections; 或 show tables; #查看库中的所有集合
⑶ 删除库中集合: db.集合名.drop() ;
> use ems; #进入ems数据库
> show collections; # 查看库中有哪些集合。
> db.t_user.drop(); # 删除t_user集合。
> show collections; # 查看将t_user删除后，t_user是否存在。
⑷ 集合相关的帮助指令：db.集合名.help()
> use ems; #进入ems数据库
> db.t_user.help() # 查看库中某一个集合的帮助指令。
-------------------------------------------------
3. mongodb中集合的详细操作(CRUD增删改查)
⑴ 向集合中添加一条记录：db.集合名称.insert({"key":"value", "key1":"value1",....... )};
> use ems; #进入ems数据库
> show collections; # 查看库中有哪些集合。
> db.t_emp.insert({"name":"wangmazi",age:20,sex:true,bir:"2012-12-12"}); # 向集合t_emp中添加一条记录
➀ 在insert("key":"value") 中，key可以不加双引号("")，
value 如果不加双引号("")则代表这个插入的值是一个数字类型，
如果加双引号则代表此值是字符串类型。若是日期的话在mongodb中
实际上也是一个字符串类型的值，因此'日期'的值直接加上双引号即
可。
➁ mongodb中所插入的'数字类型'是不区分'小数'和'整数'的。
⑵ 查看集合中的所有记录：db.集合名称.find()
> use ems; #进入ems数据库
> show collections; # 查看库中有哪些集合。
> db.t_emp.find(); #查询t_emp结合下的所有数据
{ "_id" : ObjectId("6166493e908a8aadd402eab0"), "name" : "wangmazi", "age" : 20, "sex" : true, "bir" : "2012-12-12" }
➀ 注意1：在mongodb中一定会在底层帮我们生成一个'_id'的key和
value。我们可以自己去指定此'_id'的值，操作指令为↓：
# 在ems数据下的t_emp集合中去创建一条记录，并制定"_id"的值。
>db.t_emp.insert({"_id":"20211013_1","name":"wangwu"});
# 查看在't_emp'集合下创建记录后的结果数据：
> db.t_emp.find();
{ "_id" : ObjectId("6166493e908a8aadd402eab0"), "name" : "wangmazi", "age" : 20, "sex" : true, "bir" : "2012-12-12" }
{ "_id" : "20211013_1", "name" : "wangwu" }
➁ 注意2：我们去指定"_id"的值时，去key必须取名为"_id"，才可
以去指定它的具体value值。因此正常在mongodb的某一个数据库下
的集合中插入一条数据时，mongodb会默认在插入时自动创建一
个"_id"的key，并生成一个随机的默认值(此值我们可以自己去指
定)。
⑶ 向集合中插入多条记录(在括号内嵌入一个[]括号，里面插入多条中括
号{}的记录数据)
-->db.集合名称.insert([{"key":"value",...},{"key1":"value1",...}]};
➀ mongodb客户端：插入多条记录命令演示：
#进入ems数据库
> use ems;
# 查看库中有哪些集合
> show collections;
# 以上表示一次插入多条记录。
> db.t_emp.insert([{"id":"21","name":"wangxiaoer"},{"name":"xiaoming"},{"name":"windows7",age:23}]);
# 查看一次插入3条数据的结果信息
> db.t_emp.find();
{ "_id" : ObjectId("61664e2823dff133127daa3e"), "id" : "21", "name" : "wangxiaoer" }
{ "_id" : ObjectId("61664e2823dff133127daa3f"), "name" : "xiaoming" }
{ "_id" : ObjectId("61664e2823dff133127daa40"), "name" : "windows7", "age" : 23 }
➁ mongodb 支持使用JS语法插入多条数据(mongodb对js的脚本有
一定的支持)。
-->使用JS的for循环插入多条数据，如图所示-"图-js语法插入多条
数据"。
# 使用JS语法往mongodb中插入多条数据：
for(var i=0;i<100;i++) (
db. 集合名称. inert({......});
}
⑷ 删除集合中的记录：db.集合名称.remove({"删除条件"}); # 删除
条件为空则默认删除所有
#进入ems数据库
> use ems;
# 查看库中有哪些集合
> show collections;
t_emp
# 无删除条件，默认删除t_emp集合下的所有数据
> db.t_emp.remove({});
# 指定删除条件去删除结合下的指定数据(指定'删除name为张
三'和'age为20'的数据)
--->指定多个条件进行删除数据，并集'and'(两个条件需同时满足)
的关系进行删除。
> db.t_emp.remove({name:"张三",age:20});
⑸ 修改集合中的记录
➀ db.集合名称.update({更新条件},{更新内容});
▲. 注意1：使用这种方式的更新会'先将符合的数据删除，然后在将
修改的数据添加进去'。
➁ db.集合名称.update({更新条件},{$set:{age:21,"address":
["北京"，"上海"]}});
--->此命令表示：根据更新条件去获取记录，若存在'age'数据则数
据更新为21，若不存在
'address'数据或'age'数据则将数据添加进去。
▲. 注意2：使用这种方式的更新mongodb只能修改符合条件的第一条
记录
➂ db.集合名称.update({"name":"zhangsan"},{$set:
{age:17}},{multi:true});
--->此命令表示：根据"name=zhangsan"这个条件去将'age'的key
修改为17，若age存在则修改，age不存在则条件，"multi:true"的
意思是：如果匹配多条数据则全部匹配的数据进行更新修改。
▲. 注意3：使用这种方式的更新mongodb 会更新符合条件的多条记
录数据。
(multi=true)是开启多行更新，默认是false。
➃ db.集合名称.update({"name":"xxx"},{$set:{age:26}},
{multi:true,upsert:true});
--->此命令表示：根据"name=xxx"这个条件去匹配查询数据，若不
存在此数据则将'age:26'这条数据插入进去。配置
了'upsert:true'就可以实现将没有符合条件的数据将要更新的数据
插入进去。
-->'upsert:true'：没有符合条件时插入数据。
-->'multi:true'：开启多行更新。
▲. 注意4：使用这种方式的更新mongodb，对于添加
了'upsert:true'会将没有服务条件的数据插入到mongodb中。
➄ 小结：整个mongodb中的修改器总共有两个：$set + $inc
$inc：让某个集合中的数字类型的key自增多少(使用$inc让指定
字段自增长指定步长)
db.集合名称.update({"name":"zhangsan"},{$inc:
{age:10,id:1}});
--->此使用了"$inc"指令的意思为：将条件为
("name":"zhangsan")的数据将里面的"age自增10和id自增1"。
⑹ 查询集合中的记录
➀ db.集合名称.find(); # 查询集合中所有数据
➁ db.集合名称.count(); #查询集合总条数
5. mongodb中的查询基本使用
1. 下面对MongoDB中集合的相关操作(mongodb查询基本指令)进行演示。
--->集合查询操作。
⑴ 查询所有：db.集合名称.find();
⑵ 查询一个：db.集合名称.findOne(); 加入条件查询福州添加数据，
没加入添加查询第一条数据。
⑶ 条件查询：
db.集合名称.find({"name":"xxx",...}})|findOne({"name":"xxx",.....});
--->若存在多个条件则它们之间的关系是'and'(必须满足所有条件才可
以)。
▲. 注意：如果使用findOne()根据指定条件查询出来的数据有多条，则
显示满足条件的第一条数据。
⑷ 指定查询结果显示的key：
➀ 语法格式：db.集合名称. find({查询条件}, {}用来指定显示字
段1});
db.t_user.find({},(name:1, age:1})
➁ 0和1参数说明：
0：代表查询的结果中不显示这个字段
1：代表查询的结果中只显示哪个字段
➂ 注意：在查询条件中不能同时使用"0"和"1"。
⑸ 查询结果排序
➀ db.集合名称.find().sort({条件 name:1,age:-1})
1：代表升序
-1：代表降序
➁ 例子：
db.t_user.find().sort({age:-1});
--->将查询结果根据'age'进行降序排序。
⑹ 分页查询：
➀ 语法格式：db.集合名称.find({...}).skip(起始条
数).limit(每页显示记录数);
➁ 例子：
db.t_user.find().sort({age:-1}).skip(0).limit(2);
--->表示：查询集合t_user，根据age的降序查询，查询第一
页每页显示2条数据。
db.t_user.find().sort({age:-1}).skip(2).limit(2);
--->表示：查询集合t_user，根据age的降序查询，查询第二
页每页显示2条数据。
➂ 通用语法：db.集合名称.find({...}).skip((pageNow-
1)*pageSize).limit(pageSize);
-->因此这里的分页和'mysql'的分页语法是一模一样的。
⑺ 总条数查询
➀ db.集合名称.count(); #查询集合总条数
➁ db.集合名称.find({查询条件}).count(); #基于条件查询之后
的总条数
db.t_user.find({age:20}).count(); #表示查询'age为
20'的数据的总条数。
⑻ 模糊查询：通过'正则表达式'来模拟的查询。
➀ 在mongodb中并没有给我们提供'模糊查询'的查询语法，mongodb
中没有'Like'，因此如果打算在mongodb中实现模糊查询的相关操作
只能去使用'正则表达式'。
--->正则表达式是以'/'开头，'/'结尾的，然后在两个斜杠"/"中间
加入要哪个字段中包含的数据。
db.t_user.find({name:/ao/})
-->表示：查询't_user'集合中name包含'ao'值的数据。
-->注意：在/ao/ 两边不要加双斜杠。
➁ mongodb 使用正则表达式的'错误和正确'写法：
db.集合名称.find({name: "/ao/"}); //错误写法
db.集合名称.find({name:/ao/}); //正确写法
--->注意:不要在使用正则表达式时加入双引号.
-----------------------------------------------------
2. mongodb中的高级查询语法
⑴ 等值查询(=)：$eq
➀ 等值查询的两种语法使用方式
a. 方式一：
db.集合名称.find({name:"zhangsan"});
b. 方式二：
db.集合名称.find({name:{$eq:"zhangsan"}});
⑵ 且(and)查询：多条件并列查询，需同时满足条件。
# 以下演示两个实现且查询的方式
➀ 方式一：
db.集合名称.find({name:"aa",age:20});
--->查询集合中符合'name为aa'并且'age为20'的数据。
➁ 方式二：使用'$and'
db.集合名称.find({
$and:[
{name:"aa"},
{age:20}
]
});
--->使用'$and'来实现并列查询，将两个条件连接到一起实现查
询。
⑶ or 查询($or)：根据查询结果只要符合任意一个条件即可。
➀ $or 使用语法
db.集合名称.find({
$or:[
{name:"a"},
{age:20}
]
});
--->以上表示：只要满足'name为a'或者'age为20'其中一个条件即
可实现数据查询。
➁ 另一种写法
db.集合名称.find({
$or:[
{name:"a"，age:30},
{age:20}
]
});
--->以上表示：我们在同一个{}中写入两个条件就表示
'name=a且age=30'这两个条件必须同时满足，或者满足age=20这个
条件的数据均会被查询出来。所以写在同一个{}中的数据需要同时满
足的关系。
⑷ 运算相关：>($gt), <($lt)， >=($gte), <=($glte), =($eq)
# 运算相关例子说明
➀ db.t_user.find({age:{$eq:15}})
---->查询集合't_user'中age等于15的数据。
➁ db.t_user.find({age:{$gt:15}})
---->查询集合't_user'中age大于15的数据。
➂ db.t_user.find({age:{$lte:15}})
---->查询集合't_user'中age小于等于15的数据。
➃ 区间查询案例演示：
# 案例一： 查询'age'年龄大于3，小于等于15的数据。
db.t_user.find({age:{$gt:3,$lte:15}})
# 案例二：查询name为zhansgan，或者age大于3，小于等于15
的数据
db.t_user.find({
$or:[
{name:"zhangsan"},
{age:{$gt:3,$lte:15}}
]
});
⑸ not or ($nor)：查询'既不是条件1，也不是条件2'之外的数据
➀ not or 例子：
# 查询集合t_user中数据既不包含'name=a'也不包含'age=8'之外
的数据。
db.t_user.find(
{$nor:[
{name:"a"},
{age:8}
]});
6. java集成mongodb
1.注意：无论使用'java亦或springboot操作mongoDB'
我们都需要去引入mongoDB的java客户端依赖。
6.1 实战一：Java操作mongoDB
1. Java操作mongoDB代码实战，如下所示↓：
⑴ 第一：pom.xml引入相关依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.linzk</groupId>
<artifactId>mongoDBclient</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.0</version>
<scope>provided</scope>
</dependency>
<!-- mongodb 与 java连接的依赖 -->
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>
⑵ 第二：代码完成Java集成mongoDB
➀. mongoClient客户端代码演示一：
/**
* MongoDB基础APi
*/
public class mongoClient {
/*
java操作mongoDB
1. 注意：在mongoDB3.6之后，它默认只允许localhost进行连接，
因此我们需要去实现远程连接mongoDB的话，需要做如下操作：
第一步：关闭linux系统的防火墙。
第二步：开启mongoDB的多客户端连接
-->在启动mongodb时候执行开启多客户端连接。
./mongod --port=27017 --dbpath=/root/data --bind_ip 0.0.0.0
*/
private MongoClient mongoClient;
@Before
public void before() {
mongoClient = new MongoClient("192.168.35.163", 27017);
}
//获取mongoDB中所有数据库名
@Test
public void testDatabaseNames() {
MongoIterable<String> mongoIterable = mongoClient.listDatabaseNames();
for (String dataBaseName : mongoIterable) {
System.out.println(dataBaseName);
}
}
/*
获取所有集合名称
*/
@Test
public void test() {
//获取指定库
MongoDatabase ems = mongoClient.getDatabase("ems");
//获取所有集合
MongoIterable<String> mongoIterable = ems.listCollectionNames();
for (String name : mongoIterable) {
System.out.println(name);
}
}
//获取指定集合
@Test
public void test2() {
MongoDatabase ems = mongoClient.getDatabase("ems");
MongoCollection<Document> t_emp = ems.getCollection("t_emp");
System.out.println(t_emp);
}
//获取集合中的所有数据
@Test
public void test3() {
MongoCollection<Document> collection = mongoClient.getDatabase("ems").getCollection("t_emp");
FindIterable<Document> documents = collection.find();
for (Document document : documents) {
System.out.println(document.get("name" + "======"));
System.out.println(document.get("age" + "======"));
}
}
/*
保存一条记录
*/
@Test
public void test4() {
MongoDatabase ems = mongoClient.getDatabase("ems");
MongoCollection<Document> t_emp = ems.getCollection("t_emp");
Document document = new Document();
document.put("_id","1001");
document.put("name","xx20211014");
document.put("age",23);
document.put("bir",new Date());
t_emp.insertOne(document);
}
//保存多条数据
@Test
public void test5() {
MongoDatabase ems = mongoClient.getDatabase("ems");
MongoCollection<Document> t_emp = ems.getCollection("t_emp");
List<Document> list = new ArrayList<Document>();
Document document = new Document();
document.put("_id","1002");
document.put("name","aa20211014");
document.put("age",25);
document.put("bir",new Date());
Document document1 = new Document();
document1.put("_id","1003");
document1.put("name","ss20211014");
document1.put("age",26);
document1.put("bir",new Date());
list.add(document);
list.add(document1);
t_emp.insertMany(list);
}
//删除一条记录
@Test
public void test6() {
MongoCollection<Document> t_emp = mongoClient.getDatabase("ems").getCollection("t_emp");
Document document = new Document();
document.put("_id","20211013_1");
t_emp.deleteOne(document);
}
//删除多个数据
@Test
public void test7() {
MongoCollection<Document> t_emp = mongoClient.getDatabase("ems").getCollection("t_emp");
Document document = new Document();
document.put("_id","1001");
t_emp.deleteMany(document);
}
//查询总条数
@Test
public void test8() {
MongoCollection<Document> t_emp = mongoClient.getDatabase("ems").getCollection("t_emp");
System.out.println("t_emp库下的集合总条数为：" + t_emp.count());
}
@After
public void after() {
mongoClient.close();
}
}
----------------------------------------------------
➁ TestMongo001代码实现演示二：
public class TestMongo001 {
private MongoClient mongoClient;
@Before
public void before(){
mongoClient = new MongoClient("192.168.28.136",27017);
}
/**
* 获取所有集合名称
*/
@Test
public void testGetCollectionNames(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoIterable<String> strings = database.listCollectionNames();
for (String name : strings) {
System.out.println(name);
}
}
/**
* 获取指定的集合
*/
@Test
public void testGetCollection(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> collection = database.getCollection("t_user");
}
/**
* 获取指定集合中的所有数据
*/
@Test
public void testGetCollectionFindAll(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> collection = database.getCollection("t_user");
FindIterable<Document> documents = collection.find();
for (Document document : documents) {
System.out.println(document);
System.out.print(document.get("name")+"===");
System.out.print(document.get("age")+"===");
System.out.println();
}
}
/**
* 保存一条数据
*/
@Test
public void testSave(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> t_user = database.getCollection("t_user");
Document document = new Document();
document.put("_id","1");
document.put("name","xiaochen");
document.put("age",23);
document.put("bir",new Date());
t_user.insertOne(document);
}
/**
* 保存多条数据
*/
@Test
public void testSaveMany(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> t_user = database.getCollection("t_user");
List<Document > list = new ArrayList<Document>();
Document document = new Document();
document.put("_id","3");
document.put("name","aaa");
document.put("age",23);
document.put("bir",new Date());
Document document1 = new Document();
document1.put("_id","2");
document1.put("name","bbbb");
document1.put("age",23);
document1.put("bir",new Date());
list.add(document);
list.add(document1);
t_user.insertMany(list);
}
/**
* 删除一条数据
*/
@Test
public void testDelete(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> t_user = database.getCollection("t_user");
Document document = new Document();
document.put("_id",1);
t_user.deleteOne(document);
}
/**
* 删除多个数据
*/
@Test
public void testDeleteMany(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> t_user = database.getCollection("t_user");
Document document = new Document();
document.put("name","ccc");
t_user.deleteMany(document);
}
/**
* 查询总条数
*
*/
@Test
public void tesCount(){
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> t_user = database.getCollection("t_user");
System.out.println(t_user.count());
}
@After
public void after(){
mongoClient.close();
}
}
6.2 实战二：Springboot操作mongoDB
1. Springboot操作mongoDB代码演示，如下所示↓：
⑴ 第一：实验springboot集成mongoDB 依赖引入：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>microservice_parent</artifactId>
<groupId>com.linzk</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springboot_mongoDBclient</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- mongodb 与 java连接的依赖 -->
<!-- <dependency>-->
<!-- <groupId>org.mongodb</groupId>-->
<!-- <artifactId>mongo-java-driver</artifactId>-->
<!-- <version>3.0.0</version>-->
<!-- </dependency>-->
<!--
引入springboot-mongodb的依赖
此依赖的底层已经自动引入了上面的(mongo-java-driver依赖)，因此不需要在重复引入"mongo与java连接的依赖包"
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
</dependencies>
</project>
⑵ 第二：创建三个对象类
➀ Order实体类
@Document(collection="t_order")
public class Order {
@Id
@Indexed //此注解用来创建索引
private Object id;
@Field("order_ num") //此注解表示：指定orderNum在集合中的名字为"order_num"
private String orderNum;
private Date createDate;
// 映射忽略的字段，该字段不会保存到mongodb。
@Transient
private String cc;
//Get和Set方法，toString()方法。
}
➁ Person 实体类
@Document(collection="t_person")
public class Person {
@Id // 主键类型只能为：String，ObjectId,BigInteger
private String id;
private String name;
private int age;
private double salary;
/**
* @DBRef //此注解：表示此orders 是一个关系属性。
* 加上此注解的好处：日后你查询Person对象的值时，可以直接将Order对象数据
* 直接查询出来。同时在保存Person数据时，将Order信息也保存进去。
*/
//一个Person有多个订单。一般我们都是通过:"一的一方去查询多的一方"
@DBRef
private List<Order> orders = null;
➂ User实体类
/**
* 若打算将此User对象存储到'MongoDB'中，我们必须让User对象
* 实现序列化接口
*/
@Data
@Document(collection = "t_user") //设置存储到集合中数据的名称
public class User implements Serializable {
@Id //指定将当前的'id'去映射'_id'
private String id;
private String name;
private Integer age;
@Transient //此注解表示：在对象进行序列化时，当前这个属性不参与对象序列化
private Date bir;
}
➃ application.yml 配置文件配置：
spring:
data:
mongodb:
database: ems #指定连接的mongoDB下的数据库名
uri: mongodb://192.168.35.163:27017 #指定连接mongodb所在的服务器IP地址和端口号
⑶ 第三：在测试包'test'下使用直接调用"MongoTemplate 模板类"操作mongoDB即可
➀ springboot操作mongodb演示一：
/**
* K
*/
@SpringBootTest(classes = SpringBootMongoDBApplication.class)
@RunWith(SpringRunner.class)
public class SpringbootTestMongoDBTemplate {
@Autowired
private MongoTemplate mongoTemplate;
/*
简单演示往mongodb添加数据
*/
@Test
public void testSave() {
User user = new User();
user.setId(UUID.randomUUID().toString());
user.setName("诸葛青");
user.setAge(23);
user.setBir(new Date());
mongoTemplate.save(user);
}
}
➁springboot操作mongodb演示二：
@SpringBootTest(classes = SpringBootMongoDBApplication.class)
@RunWith(SpringRunner.class)
public class TestMain01 {
@Autowired
private MongoTemplate temp;
@Test
public void test09() {
Person person = temp.findById("1001", Person.class);
System.out.println(person);
List<Order> orderList = person.getOrders();
System.out.println(orderList);
for (Order order : orderList) {
//遍历打印输出订单信息
System.out.println(order);
}
}
//根据主键id查询
@Test
public void test08() {
Person person = temp.findById("1001", Person.class);
System.out.println(person.getOrders());
}
//测试有级联关系的两个对象
@Test
public void test06() {
Person p = new Person("1001", "zhangsan", 23, 111111);
List<Order> list = new ArrayList<Order>();
for (int i = 0; i < 3; i++) {
ObjectId objectId = new ObjectId(new Date());
Order order = new Order(objectId, 111111 + "_" + i, new Date());
temp.save(order);
list.add(order);
p.setOrders(list);
;
temp.save(p);
}
}
//删除数据
@Test
public void test05() {
Person s = new Person();
s.setId(1 + "");
temp.remove(s);
}
//查询person表中的所有数据
@Test
public void test03() {
List<Person> list = temp.findAll(Person.class);
for (Person s : list) {
System.out.println(s);
}
}
//添加数据
@Test
public void test02() {
/*
for(int i = 0 ; i< 5;i++) {
Student s = new Student(10+i+"", "zhangsan"+i, 12*i, 2000+i);
temp.save(s);
}
*/
//主键如果存在,进行更新
/*
Student s = new Student ("2","zhangsan",111,2000);
temp.save(s);
*/
/*
insert方法:如果key存在，报错
*/
Person s = new Person("2","aa", 100, 2000);
temp.insert(s);
}
//查询所有的库
@Test
public void test01() {
/*
List<String> list = mongo.getDatabaseNames();
for (String dbName : list) {
System.out.printIn(dbName) ;
}
*/
}
}
7. 阶段小结
以上主要对mongodb的基本介绍和集成java的使用做一个简单介绍。后续对于mongodb的’主从复制，副本集和分片’待更新中…
362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
