简单的 mongoDB 学习

简单的 mongoDB 学习

一. 下载与安装

1. 下载monagoDb

下载地址为 https://www.mongodb.com/try/download/community-kubernetes-operator ，学习使用社区版本

2.安装monagodb

1. 注意安装目录自定义一下，不要安装到C盘。其余则是一直下一步即可。
2. 进行环境变量的配置

3. 使用mongod -version 观察是否安装成功，由于6.x.x版本不太好用，修改成5.x版本

二. 基础命令学习

1.数据库整体信息查询

查看所有的数据库：show dbs /show databases
切换数据库：use db_name
查看使用当前的数据库：db
删除当前的数据库：db.dropDatabase()
查看数据库中所有集合（表）：show collections
查看指定集合下所有文档（JSON数据）：db.集合名称.find()

查看数据库信息：db.stats()

2.集合命令学习

一般来说，无需手动创建集合，首次插入会自动创建集合信息

手动创建结合：

• db.createCollection(name, options)

• db.createCollection(“contract”)

• db.createCollection(“contract”, { capped : true, size : 20 } )

  参数capped： 默认值为false表示不设置上限,值为true表示设置上限

  参数size： 当capped值为true时， 需要指定此参数， 表示上限⼤⼩,当⽂档达到上限时， 会将之前的数据覆盖， 单位为字节

• show collections 展示当前数据库中集合

• db.集合名称.drop() 删除集合

3.mongoDb数据类型

• **注意：**标注红色为常用类型

• 日期创建语句： new Date(‘2017-12-20’)

• 每个⽂档都有⼀个属性， 为 _id ， 保证每个⽂档的唯⼀性

  可以⾃⼰去设置 _id 插⼊⽂档，如果没有提供， 那么MongoDB为每个⽂档提供了⼀个独特的_id ， 类型为objectID

  objectID是⼀个12字节的⼗六进制数：

  • 前4个字节为当前时间戳

  • 接下来3个字节的机器ID

  • 接下来的2个字节中MongoDB的服务进程id

  • 最后3个字节是简单的增量值

4.insert 插入操作

常用语法如下：

• db.集合名称.insert(JSON对象)
• 插入1条数据：db.集合名称.insertOne(JSON对象)
• 插入多条数据：db.集合名称.insertMany([JSON 1，JSON 2，JSON 3，…JSON n])
• 指定_id参数：db.集合名称.insert({_id:“00001”, name:“jack”, sex:0})

注意：

• 插入数据时不需要专门去创建集合(表)，因为插入数据时会自动创建集合
• 插⼊⽂档时， 如果不指定_id参数， MongoDB会为⽂档分配⼀个唯⼀的ObjectId
• 如果⽂档的_id已经存在则报错

执行语句如下：

--法人信息
db.tb_csm_corporation.insertMany([
    {name: "王五", age: 18, sex: "男", hobby: "美女11"},
    {name: "大力", age: 20, sex: "男", hobby: "酒吧"},
    {name: "德胜", age: 21, sex: "男", hobby: "吐痰"},
	{name: "海格力斯", age: 21, sex: "女", hobby: "common on"},
	{name: "jeny", age: 21, sex: "女", hobby: "common on"},
	{name: "jack", age: 21, sex: "女", hobby: "common on"}
]);
--个人信息
db.tb_csm_individual.insertMany([
    {name: "王五", age: 18, sex: "男", hobby: "美女11"},
    {name: "大力", age: 20, sex: "男", hobby: "酒吧"},
    {name: "德胜", age: 21, sex: "男", hobby: "吐痰"},
	{name: "海格力斯", age: 21, sex: "女", hobby: "common on"},
	{name: "jeny", age: 21, sex: "女", hobby: "common on"},
	{name: "jack", age: 21, sex: "女", hobby: "common on"}
]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.简单查询语句

具体查询语法为 db.集合名称.find()

6.保存数据信息

具体执行语句为 db.集合名称.save(document)

注意：如果⽂档的 _id 已经存在则修改， 如果⽂档的_id不存在则添加

7.修改数据信息

具体修改的语法格式信息

• db.集合名称.update( ,,{multi: })

• 更新一条（字段全部替换）：db.集合名称.update({name:‘原始数据’},{name:‘修改后数据’})

• 更新一条（仅更新一个字段）：db.集合名称.update({name:‘原始数据’},{$set:{name:‘修改后数据’}}) ，推荐使用

• 更新全部：db.集合名称.update({name:‘原始数据’},{$set:{name:‘修改后数据’}},{multi:true})

  参数 query：查询条件

  参数 update：更新操作符

  参数 multi：可选， 默认是false，表示只更新找到的第⼀条记录， 值为true表示把满⾜条件的⽂档全部更新

  注意：{multi:true}需要和 $set 配合使用

具体使用案例

1. 使用 db.集合名称.update({name:‘原始数据’},{name:‘修改后数据’}) 修改，只保留修改字段，其余原有字段删除，不推荐使用

2. 推荐增加参数**$set**，修改时候只修改标记变量，其余变量不进行修改,

3. 如果想全部修改，可以使用 multi:true属性

8.删除数据操作

具体删除数据格式 db.集合名称.remove(,{justOne: })

• 参数query:可选，删除的⽂档的条件
• 参数justOne:可选， 如果设为true或1， 则只删除⼀条， 默认false， 表示删除多条

删除单条数据

不带justOne则删除多条数据

9.高级查询

9.1 准备 数据信息

db.tb_csm_corporation.insertMany([
    {name: "王五", age: 18, sex: "男", hobby: "美女11"},
    {name: "大力", age: 20, sex: "男", hobby: "酒吧"},
    {name: "德胜", age: 21, sex: "男", hobby: "吐痰"},
	{name: "海格力斯", age: 21, sex: "女", hobby: "common on"},
	{name: "jeny", age: 21, sex: "女", hobby: "common on"}
]);
1
2
3
4
5
6
7

9.2 基本条件查询

• 条件查询：db.集合名称.find({条件⽂档})
• 查询只返回第⼀个：db.集合名称.findOne({条件⽂档})
• 将结果格式化：db.集合名称.find({条件⽂档}).pretty()

9.3 比较运算

运算符如下：

• 等于： 默认是等于判断， 没有运算符

• ⼩于：$lt （less than）

• ⼩于等于：$lte （less than equal）

• ⼤于：$gt （greater than）

• ⼤于等于：$gte

• 不等于：$ne

格式：db.集合名称.find({xxx:{$gte:18}})

9.4 范围运算符 in/nin

运算符：$in(‘代表在条件内‘)，$nin(代表不在条件内)

9.5 逻辑运算符and/or

• and：在json中写多个条件即可

  格式：db.集合名称.find({条件1, 条件2})

• or：使⽤$or， 值为数组， 数组中每个元素为json

  格式：db.集合名词.find({$or:[{条件1}, {条件2}]})

9.6 正则表达式

使⽤//或$regex编写正则表达式

格式1：db.集合名称.find({name:/^jack/})

格式2：db.集合名词.find({name:{$regex:'^tom'}})

9.7 查询指定数量信息

⽤于读取指定数量的⽂档：db.集合名称.find().limit(number)

⽤于跳过指定数量的⽂档：db.集合名称.find().skip(number)

同时使用：

• db.集合名称.find().limit(number).skip(number)
• db.集合名称.find().skip(number).limit(number) [推荐使用效率会更高]

9.8 自定义查询

$where后⾯写⼀个函数， 返回满⾜条件的数据

db.集合名称.find({
    $where:function() {
        return this.条件;}
})
1
2
3
4

查询自己想要的字段，其余字段不显示

db.集合名称.find({条件（可省略）},{字段名称:1,…})

• 参数为字段与值， 值为1表示显示， 不显示则不用写
• 特殊： 对于_id列默认是显示的， 如果不显示需要明确设置为 0

9.9 排序 sort

基本语法：db.集合名称.find().sort({字段:1,…})

• 参数1为升序排列
• 参数-1为降序排列

9.10 统计个数

统计结果集中⽂档条数：

• db.集合名称.find({条件}).count()
• db.集合名称.count({条件})

9.11 去除重复

db.集合名称.distinct(‘去重字段’,{条件})

三.聚合管道

1. 聚合简介

聚合(aggregate)是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果。

语法格式：db.集合名称.aggregate({管道:{表达式}})

2.常用管道

在mongodb中，⽂档处理完毕后， 通过管道进⾏下⼀次处理

常用管道如下：

• $group： 将集合中的⽂档分组， 可⽤于统计结果

• $match： 过滤数据， 只输出符合条件的⽂档

• $project： 修改输⼊⽂档的结构， 如重命名、 增加、 删除字段、 创建计算结果

• $sort： 将输⼊⽂档排序后输出

• $limit： 限制聚合管道返回的⽂档数

• $skip： 跳过指定数量的⽂档， 并返回余下的⽂档

• $unwind： 将数组类型的字段进⾏拆分

表达式：

• $sum： 计算总和， $sum:1 表示以⼀倍计数
• $avg： 计算平均值
• $min： 获取最⼩值
• $max： 获取最⼤值
• $push： 在结果⽂档中插⼊值到⼀个数组中
• $first： 根据资源⽂档的排序获取第⼀个⽂档数据
• $last： 根据资源⽂档的排序获取最后⼀个⽂档数据

2.1 group

将集合中的文档分组，可用于统计结果，_id表示分组的依据，使用某个字段的格式为’$字段’

查询sex分别有哪些值

db.tb_csm_corporation.aggregate(
	{$group:{
		_id:"$sex"
		}
	}
)
1
2
3
4
5
6

按照sex分组，分别查询各组共有多少人

db.tb_csm_corporation.aggregate(
	{$group:
		{
		_id:"$sex",
        # 此处为自定义列
		cus_count:{$sum:1}
		}
	}
)
1
2
3
4
5
6
7
8
9

按照sex分组，分别查询各组多少总数以及平均年龄信息

db.tb_csm_corporation.aggregate(
	{$group:
		{
		_id:"$sex",
		count:{$sum:1},
		avg_age:{$avg:"$age"}
		}
	}
)
1
2
3
4
5
6
7
8
9

按照sex分组，统计每组人的名字

db.tb_csm_corporation.aggregate(
	{$group:
		{
		_id:"$sex",
		name:{$push:"$name"}
		}
	}
)
1
2
3
4
5
6
7
8

使用$$ROOT可以将文档内容加入到结果集的数组中

db.tb_csm_corporation.aggregate(
	{$group:
		{
		_id:"$sex",
		name:{$push:"$$ROOT"}
		}
	}
)
1
2
3
4
5
6
7
8

_id:null：将集合中所有文档分为一组

查询当前结果集总数以及平均年龄

db.tb_csm_corporation.aggregate(
	{$group:
		{
		_id:null,
		count:{$sum:1},
		avg_age:{$avg:"$age"}
		}
	}
)
1
2
3
4
5
6
7
8
9

多字段分组,使用sex以及name分组，并且取得对应name组合信息

db.tb_csm_corporation.aggregate(
	{$group:
		{
		_id:{sex:"$sex",name:"$name"},
		name:{$push:"$name"}
		}
	}
)
1
2
3
4
5
6
7
8

group 总结

• $group对应的字典中有几个键，结果中就有几个键

• 分组依据需要放到_ id后面

• 取不同的字段的值需要使用$，如：$hometown、$age、$sex

• 取字典嵌套的字典中值的时候$id.字段名

  同时取多个键进行分组：{KaTeX parse error: Expected '}', got 'EOF' at end of input: …up:{_id:{字段名1:"字段名1",字段名2:“字段名2”}}}；输出结果：{_id:{字段名1:“”,字段名2:“”}

2.2 project

修改输入文档的结构，如重命名、增加、删除字段、创建计算结果；简单来说就是修改输入输出的值

查询结果集只显示name,age两列

db.tb_csm_corporation.aggregate(
	{$project:{
		_id:0, name:1, age:1}
	}
)
1
2
3
4
5

按性别排序，查询男女人数，并且只输出人数信息

db.tb_csm_corporation.aggregate(
	{$group:{_id:'$sex', count:{$sum:1}}},
	{$project:{_id:0, count:1}}
)
1
2
3
4

2.3 match

用于过滤数据，只输出符合条件的文档，其特点如下：

• 使用MongoDB的标准查询操作
• match是管道命令，能将结果交给后一个管道，但是find不可以

查询年龄大于20的人员信息

db.tb_csm_corporation.aggregate(
	{$match:{age:{$gt:20}}}
)
1
2
3

查询年龄大于等于18的男生、女生人数

db.tb_csm_corporation.aggregate(
	{$match:{age:{$gte:18}}},
	{$group:{_id:'$sex',count:{$sum:1}}}
)
1
2
3
4

2.4 sort

按照年龄升序排序

db.tb_csm_corporation.aggregate({$sort:{age:1}})
1

按照性别分组，分组结果再按人数降序

db.tb_csm_corporation.aggregate({$limit:2})
1

2.5 limit & skip

限制聚合管道返回的文档数量

跳过指定数量的文档，并返回余下的文档

db.tb_csm_corporation.aggregate({$skip:2})
1

从第三条数据开始，返回1条数据

db.tb_csm_corporation.aggregate(
	{$skip:2},
	{$limit:1}
)
1
2
3
4

2.6 unwind

将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值

基本语法：

• db. 集合名称.aggregate({$unwind:'$字段名称’})

将大壮的t-shirt尺码进行拆分

查询大壮有多少个t-shirt尺码

db.tb_csm_corporation.aggregate(
	{$match:{username:"大壮"}},
	{$unwind:"$size"},
	{$group:{_id:null, sum:{$sum:1}}}
)
1
2
3
4
5

属性preserveNullAndEmptyArrays值为true表示保留属性值为空的⽂档；值为false表示丢弃属性值为空的⽂档

2.7 多集合连接查询

mongodb可以实现多集合连接查询，具体语法使用 $lookup

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}
1
2
3
4
5
6
7
8
9

连接查询语句解析

最终执行类似于sql:

SELECT *,
FROM collection
WHERE IN (SELECT *
FROM
WHERE = <collection.localField>);

具体执行案例如下:

db.tb_csm_corporation.aggregate([
   {
     $lookup:
       {
         from: "tb_csm_individual",
         localField: "name",
         foreignField: "name",
         as: "customer_info"
       }
  },
  # 内连接只需要过滤空值即可
  {
      $match: { "name":{$ne:null}}
  }
])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

如何实现条件查询，类似于前置 where 的效果，实现如下

查询name是jack的客户信息，其中个人客户name与法人客户信息name相等

db.tb_csm_corporation.aggregate([
    {
       $match:{name:/jack/}
    },
   {
     $lookup:
       {
         from: "tb_csm_individual",
         localField: "name",
         foreignField: "name",
         as: "customer_info"
       }
  }
])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

四.索引

1.索引作用

mongo索引可以很大限度加速查询速度

2.准备测试数据

插入10000条数据到库中 for(i=0;i<100000;i++){db.tb_csm_corporation.insert({name:'大壮'+i,age:i})}

执行查询语句，观察用时 语句后面 +.explain(‘executionStats’)

db.tb_csm_corporation.find({name:'大壮10000'}).explain('executionStats')
1

新增索引，再进行查询对比

• db.集合名称.createIndex({字段名:1})；其中 1 表示升序， -1 表示降序

再次执行 db.tb_csm_corporation.find({name:'大壮10000'}).explain('executionStats') 观察执行时间 发现执行时间为 0

查看当前集合索引信息 db.tb_csm_corporation.getIndexes()

删除索引信息 db.集合名称.dropIndex({'索引名称'})

创建唯一索引 db.tb_csm_corporation.createIndex({"name":1}, {"unique":true})

五.数据备份以及恢复

1.备份操作

基本语法：mongodump -h dbhost -d dbname -o dbdirectory

• -h： 指定服务器地址；如果是当前本机数据库可以去掉-h
• -port ：指定端口号；如果是默认端口可以去掉
• -d： 需要备份的数据库名称；如果不指定则导出所有数据库
• -o： 备份的数据存放位置， 此⽬录中存放着备份出来的数据
• -c： 指定集合名称；如果不指定则全部导出
• -u： 用户名；如果没有用户，可以不用指定
• -p： 密码；如果没有密码，可以不用指定

最终执行语句 mongodump -h 3.2.26.244:27017 -d ACCOUNT -o ~/Desktop/ACCOUNT

2.恢复备份信息

基本语法: mongorestore -h dbhost -d dbname --dir dbdirectory

• -h： 服务器地址
• -d： 需要恢复的数据库实例
• –dir： 备份数据所在位置

最终执行语句 mongorestore -h 3.2.26.244:27017 -d ACCOUNT --dir ~/Desktop/ACCOUNT

注意事项:

• 命名需要在终端输出，而不是数据库命令行

• 每个参数前后是有空格

• 如果执行 发现 mongodump 不是内部或外部命令，也不是可运行的程序 或批处理文件

  原因：mongodb默认时没有mogodump.exe工具和mongorestore.exe工具的，所以出现了以上问题

  需要下载工具： https://www.mongodb.com/try/download/database-tools

六.用户建立

创建用户具体语法为：

use admin
db.createUser(
	{
		user:'account',
		pwd :'account',
		customData:{"desc":"create use test"}，
		roles:[
				{
					role:'userAdminAnyDatabase',db:'admin'
				}
		]
	}
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

创建语法解析：

• user ：用户名 --必须项
• pwd ：密码 --必须项
• customData ：用于描述账户信息 --非必须项
• roles：指定用户的角色，可以用一个空数组给新用户设定空角色；在roles字段,可以指定内置角色和用户定义的角色。–必须项（可以为空集合）

角色种类解析

用户第一次使用，需要创建超级管理员账号,并且使用 db.auth(“root”, “root”)验证是否建立成功。

db.createUser({ user: "root", pwd: "root", roles:[{role: "root", db: "admin" }]}) 
db.auth("root", "root")
1
2

还需要修改mongo.conf文件，开启用户权限验证

再次登录则需要使用用户密码登录 mongo -u root -p root

案例，创建一个只对ACCOUNT库有读写权限的用户

db.createUser({user:'account',pwd:'account', roles:[{role:'readWrite',db:'ACCOUNT'}]})
db.auth("account", "account")
1
2

使用新增用户连接对应操作库 mongo -u account -p account -authenticationDatabase ACCOUNT

七.java客户端使用

1.服务代码实现

1.1 新建mongo-server服务，引入mongodb使用jar包

<?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>netflix-cloud</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.git</groupId>
    <artifactId>mongo-server</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- 引入mongodb-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
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

1.2 编写配置文件

spring:
  application:
    name: mongo-server
  # mongo 连接
  data:
    mongodb:
      # 参数解析
      # mongodb://用户名:密码@localhost:27017/库名称?authMechanism=认证方式默认就是(SCRAM-SHA-1)&authSource=具有用户凭据的集合的数据库的名称
      uri: mongodb://account:account@localhost:27017/ACCOUNT?authMechanism=SCRAM-SHA-1&authSource=ACCOUNT
server:
  port: 12000
1
2
3
4
5
6
7
8
9
10
11

注意连接具体格式:

• mongodb://用户名:密码@localhost:27017/库名称?authMechanism=认证方式默认就是(SCRAM-SHA-1)&authSource=具有用户凭据数据库的名称

1.3 编写启动类

package cn.git.mongo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @description: mongo-server服务启动类
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2023-05-08 09:15:20
 */
@SpringBootApplication
public class MongoServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(MongoServerApplication.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.4 编写controller以及实体

package cn.git.mongo.controller;

import cn.git.mongo.entity.TbCsmCorporation;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @description: 法人客户信息查询controller
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2023-05-08 10:32:05
 */
@Slf4j
@RestController
@RequestMapping("/corporation")
public class TbCsmCorporationController {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 主键查找
     * @param id
     * @return
     */
    @GetMapping("/getCorporationInfoById/{id}")
    public String getCorporationInfoById(@PathVariable(value = "id") String id) {
        TbCsmCorporation corporation = mongoTemplate.findById(id, TbCsmCorporation.class);
        return JSONObject.toJSONString(corporation);
    }

    /**
     * 修改
     * @param id
     * @return
     */
    @GetMapping("/updateCorporationInfo/{id}")
    public String updateCorporationInfoById(@PathVariable(value = "id") String id) {
        TbCsmCorporation corporation = mongoTemplate.findById(id, TbCsmCorporation.class);
        corporation.setName("张大大");
        mongoTemplate.save(corporation);
        return JSONObject.toJSONString(corporation);
    }

    /**
     * 删除
     * @param id
     * @return
     */
    @GetMapping("/deleteCorporationInfoById/{id}")
    public String deleteCorporationInfoById(@PathVariable(value = "id") String id) {
        TbCsmCorporation corporation = mongoTemplate.findById(id, TbCsmCorporation.class);
        mongoTemplate.remove(corporation);
        return JSONObject.toJSONString(corporation);
    }

    /**
     * 获取所有
     * @return
     */
    @GetMapping("/getAllCorporation")
    public String getAllCorporation() {
        List<TbCsmCorporation> corporationList = mongoTemplate.findAll(TbCsmCorporation.class);
        log.info("获取客户信息共[{}]条", corporationList.size());
        return JSONObject.toJSONString(corporationList.get(0));
    }
}
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

注意实体上面需要使用 @Document 以及 @MongoId 注解

package cn.git.mongo.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.bson.types.ObjectId;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.MongoId;

/**
 * @description: 客户信息实体
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2023-05-08 10:32:55
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document("tb_csm_corporation")
public class TbCsmCorporation {

    /**
     * 主键
     */
    @MongoId
    private ObjectId id;

    /**
     * 名称
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 年龄
     */
    private String sex;

    /**
     * 爱好
     */
    private String hobby;

}
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

2.简单测试

访问路径 http://localhost:12000/corporation/getCorporationInfoById/6455ec140e3125acdf002e5b 查看如下结果

注意:

一个集合添加关联id时，忘记使用自定义id，使得id传值为空。
MongoDB数据库的插入mongoTemplate.insert方法，如果没有传入主键id，默认会生成ObjectId类型的主键_id。开发用String类型的id去查数据库中ObjectId类型的id就返回null了。

如果使用ObjectId进行查询 语法为： mongoTemplate.findById(new ObjectId(id), 实体.class);

3. mongoTemplate使用

Criteria基本语法：

3.1 基本查询 where

基本查询语法为

// 基本query查询，设定query
Query query = new Query();
query.addCriteria(Criteria.where("数据库字段名").is("你的参数"));

// findOne 返回的是一个对象 Class代表你的表对应的映射类
mongoTemplate.findOne(query, Class.class);
mongoTemplate.find(query, Class.class);
1
2
3
4
5
6
7

3.2 in 查询

基本语法为

// in查询
query = new Query();
query.addCriteria(Criteria.where("id").in(Arrays.asList("6455ec9a0e3125acdf002e5e", "6455ff1bdd54537d1ac13f90")));
csmCorporationList = mongoTemplate.find(query, TbCsmCorporation.class);
log.info("query-in 查询结果[{}]!", JSONObject.toJSONString(csmCorporationList));
1
2
3
4
5

如果想要查询指定的数据是否在数据库的数组中，可以用以下方法

Query query = Query.query(Criteria.where(“数据库字段（数组）”).is(“你的数组”));

3.3 模糊查询

// 模糊查询
query = new Query();
query.addCriteria(Criteria.where("name").regex("德胜"));
csmCorporationList = mongoTemplate.find(query, TbCsmCorporation.class);
log.info("query-模糊查询 查询结果[{}]!", JSONObject.toJSONString(csmCorporationList));
1
2
3
4
5

3.4 返回指定字段

// 字段选择
query = new Query();
query.fields().include("name").include("sex");
query.addCriteria(Criteria.where("id").is("6455ec9a0e3125acdf002e5e"));
csmCorporationList = mongoTemplate.find(query, TbCsmCorporation.class);
log.info("query-字段选择 查询结果[{}]!", JSONObject.toJSONString(csmCorporationList));
1
2
3
4
5
6

3.5 数组字段新增删除

// 数组字段新增删除操作
query = new Query();
query.addCriteria(Criteria.where("id").is("6458943f16538a69af7f4cfb"));
// 数组中添加或删除一条数据
Update update = new Update();
// push方法可以在数组中添加一条数据
// pull方法可以在数组中删除一条数据
update.push("roomList", "0000");

mongoTemplate.updateFirst(query, update, TbCsmCorporation.class);
TbCsmCorporation corporation = mongoTemplate.findById("6458943f16538a69af7f4cfb", TbCsmCorporation.class);
log.info("query-数组操作 查询结果为[{}]!", JSONObject.toJSONString(corporation));
1
2
3
4
5
6
7
8
9
10
11
12

// todo: 不常用部分
/** 
 * List<TbCsmCorporation> batchAddList = new ArrayList<>();
 * mongoTemplate.insert(batchAddList, TbCsmCorporation.class);
 *
 * // list为复杂对象时候，查询房间编号为5的信息
 * query = new Query();
 * query.addCriteria(Criteria.where("roomList.$.no").is("5"));
 * mongoTemplate.find(query, TbCsmCorporation.class);
 *
 * // 更新时也是一样,并且带有更新条件，将房间号吗为5更新为4
 * query.addCriteria(Criteria.where("roomList").elemMatch(Criteria.where("no").is("5")));
 * update = Update.update("roomList.$.no", "4");
 *
 * // 对数据库中数字字符串排序
 * query.collation(Collation.of("zh").numericOrdering(true));
 * // 还有根据字符串排序时又是顺序并不是我们所想的字典序,加上下面这个也ok
 * query.collation(Collation.of("zh"));
 *
 * // 分页
 * query.limit(10);
 *
 * // 排序
 * Sort sort = Sort.by(Sort.Direction.DESC, "timestamp");
 * query.with(sort);
 */
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