SpringBoot整合MongoDB（从安装到使用系统化展示）_springboot集成mongodb

SpringBoot整合MongoDB（从安装到使用系统化展示）

MongoDB介绍

基础介绍

MongoDB是一种开源、面向文档的非关系型数据库管理系统（NoSQL DBMS），它以其灵活性、可扩展性和强大的查询能力而闻名。MongoDB的设计理念是为了满足现代应用中海量数据、高可用性和复杂数据模型的需求。以下是MongoDB的一些重要特点和概念：

1. 文档数据库：MongoDB使用文档（Document）来表示数据，文档类似于JSON格式的数据结构，可以包含各种类型的数据，如字符串、数字、日期、数组和嵌套文档等。
2. 面向文档：MongoDB是一种面向文档的数据库，每个文档都有一个唯一的标识符（通常称为_id），用于唯一标识文档。
3. 高可扩展性：MongoDB支持水平扩展，可以通过分片（Sharding）将数据分布到多台服务器上，以实现更高的存储容量和性能。
4. 动态模式：MongoDB不需要严格的表结构定义，文档可以自由添加和修改字段，适应数据模式的变化。
5. 强大的查询语言：MongoDB支持丰富的查询语言，可以进行复杂的查询操作，包括过滤、排序、投影、聚合等。
6. 索引支持：MongoDB支持各种类型的索引，包括单字段索引、复合索引、文本索引、地理空间索引等，以加速查询操作。
7. 复制和高可用性：MongoDB支持数据的复制和自动故障转移，确保数据的高可用性和冗余。
8. 数据存储：MongoDB将数据存储在集合（Collection）中，每个集合包含一组文档。集合类似于关系型数据库中的表格。
9. Aggregation框架：MongoDB提供了强大的聚合框架，允许开发者执行复杂的数据聚合和转换操作。

需要注意的是，MongoDB的学习和使用可能需要一些时间和经验，特别是在涉及到高可用性、安全性和性能优化等方面。建议查阅MongoDB的官方文档以及相关教程，以获取更详细的指导和信息。

使用场景

同时，大家使用MongoDB数据库的时候，需要理清楚自己想要用来干什么，想要实现什么样的效果，这里我们也做一个举例：

MongoDB 在许多不同的场景中都可以发挥重要作用，特别是在需要处理半结构化数据和需要灵活性的应用中。以下是一些适合使用 MongoDB 的常见场景：

1. 大数据存储和分析： MongoDB适合存储大量的非结构化或半结构化数据，如日志数据、社交媒体数据、传感器数据等。其灵活的模式和横向扩展能力使其成为大数据存储和分析的有力工具。

2. 实时分析： MongoDB的聚合框架和强大的查询功能使其成为实时数据分析的良好选择。您可以快速进行数据的聚合、过滤和变换，以支持实时分析需求。

3. 内容管理系统（CMS）： MongoDB可以用于构建内容管理系统，特别是对于需要处理不同类型的内容、多媒体资源以及协同编辑的平台。

4. 物联网（IoT）应用： MongoDB可以轻松处理来自多个传感器和设备的实时数据，支持物联网应用的数据存储和查询需求。

5. 移动应用： MongoDB适用于移动应用，因为它支持灵活的数据模型和可以随着应用需求变化的数据结构。

6. 实时数据存储： MongoDB可以存储实时应用产生的数据，如实时分析、即时通讯和实时监控等。

7. 社交网络： MongoDB能够有效地处理社交媒体平台的用户数据、帖子、评论、关系等。

8. 日志和事件追踪： MongoDB可以存储日志和事件数据，并支持查询和分析，以便监控和故障排除。

9. 可扩展性要求： MongoDB的横向扩展能力使其能够轻松处理大规模的数据和负载，适合需要高可扩展性的应用。

   再通俗一点，我们可以结合身边举例

   以下列出了一些可以使用MongoDB作为数据存储的场景，但是并不是必须使用MongoDB的场景：

   • 淘宝用户数据
     • 存储位置：数据库
     • 特征：永久性存储，修改频度极低
   • 游戏装备数据、游戏道具数据
     • 存储位置：数据库、Mongodb
     • 特征：永久性存储与临时存储相结合、修改频度较高
   • 直播数据、打赏数据、粉丝数据
     • 存储位置：数据库、Mongodb
     • 特征：永久性存储与临时存储相结合，修改频度极高
   • 物联网数据
     • 存储位置：Mongodb
     • 特征：临时存储，修改频度飞速

   我之所以接触MongoDB数据存储，就是因为要将聊天记录存库，同时，还要实现可查询，可检索，于是就尝试使用了该数据库！当初自己对于这个数据库的概念尚且停留在MySQL的印象中，后来发现完全两回事，所以大家不要将MySQL数据库的属性映射到MongoDB数据库！！！

MongoDB安装

安装包形式安装

当您在 CentOS 上使用tar包安装 MongoDB的时候， 需要将其添加到系统的 PATH 环境变量中时，可以通过以下步骤来进行安装、配置和设置环境变量：

1. 下载并解压 MongoDB：
   首先，从 MongoDB 的官方网站下载适用于您的操作系统和架构的压缩包。您可以使用 wget 命令来下载：

   wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.4.0.tgz
   1

   也可以直接去官网进行下载，然后上传

   

   然后解压下载的压缩包：

   tar -zxvf mongodb-linux-x86_64-4.4.0.tgz
   1

2. 移动 MongoDB 文件夹：
   将解压后的 MongoDB 文件夹移动到适当的位置，例如 /opt 目录：

   sudo mv mongodb-linux-x86_64-4.4.0 /opt/mongodb
   1

3. 创建数据和日志目录：
   创建用于存储 MongoDB 数据和日志的目录：

   sudo mkdir -p /data/db
   sudo mkdir -p /var/log/mongodb
   1
   2

4. 配置环境变量：
   打开 /etc/profile 文件以编辑系统级环境变量配置：

   sudo vi /etc/profile
   1

   在文件末尾添加以下行，将 MongoDB 的可执行文件路径添加到 PATH 环境变量：

   export PATH=/opt/mongodb/bin:$PATH
   1

   保存并退出编辑器。

5. 使环境变量生效：
   使环境变量更改生效，使其在新终端会话中可用：

   source /etc/profile
   1

6. 启动 MongoDB 服务：
   启动 MongoDB 服务器，并指定数据目录和日志路径：

   mongod --dbpath /data/db --logpath /var/log/mongodb/mongod.log --fork
   1

   可选：您还可以将 MongoDB 配置为在系统启动时自动启动：

   sudo systemctl enable mongod
   1

7. 验证 MongoDB 安装：
   运行 MongoDB Shell 来验证安装是否成功：

   mongo
   1

docker形式安装

要在Docker中安装MongoDB，您可以遵循以下步骤：

1. 首先，确保您已经安装了Docker。如果没有安装，您可以从Docker官方网站下载并安装Docker：

   https://www.docker.com/get-started

   

2. 打开终端（或命令行界面）。

3. 使用以下命令在Docker中拉取MongoDB的官方镜像：

docker pull mongo
1

4. 创建并运行MongoDB容器。以下命令将创建一个名为"my-mongodb"的MongoDB容器，并将其绑定到主机的27017端口。您可以根据需要更改容器名称和端口绑定：

docker run --name my-mongodb -p 27017:27017 -d mongo
1

5. MongoDB容器已经在后台运行。您可以使用以下命令查看正在运行的容器：

docker ps
1

6. 要连接到MongoDB容器的Mongo shell，您可以使用以下命令：

docker exec -it my-mongodb mongo
1

这将使您进入Mongo shell，可以在其中执行MongoDB命令。

7. 要停止并删除MongoDB容器，可以使用以下命令：

docker stop my-mongodb
docker rm my-mongodb
1
2

这将停止并删除名为"my-mongodb"的容器。

MongoDB远程连接

请注意，不要占用了了27017端口，否则可能导致安装失败，同时，远程连接要注意防火墙的状态，要么关闭防火墙，要么放行27017端口。

在 CentOS 操作系统中，要放行端口 27017（MongoDB 默认的端口），您需要配置防火墙规则，以允许来自外部网络的连接到达该端口。以下是在 CentOS 上放行端口 27017 的步骤：

1. 检查防火墙状态：

   首先，检查防火墙的状态，确保防火墙是活动的。您可以使用以下命令来检查防火墙状态：

   sudo firewall-cmd --state
   1

2. 添加防火墙规则：

   如果防火墙处于活动状态，您可以使用以下命令添加一个允许端口 27017 的防火墙规则：

   sudo firewall-cmd --zone=public --add-port=27017/tcp --permanent
   1

   解释：

   • --zone=public：指定要添加规则的防火墙区域。
   • --add-port=27017/tcp：添加端口 27017 的 TCP 规则。
   • --permanent：将规则永久保存，以便在重启后仍然生效。

3. 重新加载防火墙规则：

   添加规则后，需要重新加载防火墙规则才能使更改生效：

   sudo firewall-cmd --reload
   1

4. 验证规则：

   您可以使用以下命令查看已添加的防火墙规则：

   sudo firewall-cmd --list-all
   1

   确保在输出中看到包含 ports: 27017/tcp，表示端口 27017 已被允许。

现在，您已经在 CentOS 上成功放行了端口 27017，允许外部网络连接到 MongoDB。下面我们就可以是Navicat进行连接测试！

MongoDB基础语法

创建数据库

创建数据表

在 MongoDB 中，数据存储在集合（Collections）中，而不是传统的数据表。每个集合可以包含多个文档（Documents），文档类似于数据库中的行。下面是一个示例，展示如何使用 MongoDB 语法创建一个名为 “Books” 的集合，并插入一个文档：

// 连接到 MongoDB 数据库
use my_db

// 创建 "Books" 集合并插入一个文档
db.Books.insertOne({
  title: "如何使用MongoDB",
  author: "IT小辉同学",
  year: 2023
})
1
2
3
4
5
6
7
8
9

让我解释一下上述语法的每个部分：

1. use my_db：这将切换到数据库 “my_db”。如果该数据库不存在，MongoDB 会自动创建它。

2. db.Books.insertOne({ ... })：这将在当前数据库中的 “Books” 集合中插入一个文档。您可以将需要插入的数据作为一个 JSON 对象传递给 insertOne 方法。

在上面的示例中，我们创建了一个名为 “Books” 的集合，并向其中插入了一个文档，该文档包含 “title”、“author” 和 “year” 三个字段。

插入数据

单条插入

// 插入一条数据到 "Books" 集合
db.Books.insertOne({
  title: "如何使用MongoDB",
  author: "IT小辉同学",
  year: 2023
})
1
2
3
4
5
6

多条插入

// 插入十条数据到 "Books" 集合
db.Books.insertMany([
  { title: "平凡的世界", author: "路遥", year: 1986 },
  { title: "呐喊", author: "鲁迅", year: 1923 },
  { title: "朝花夕拾", author: "鲁迅", year: 1928 },
  { title: "李自成", author: "王安忆", year: 2010 },
  { title: "寻找安详", author: "郭文斌", year: 2000 },
  { title: "推拿", author: "毕飞宇", year: 1999 },
  { title: "苏东坡传", author: "林语堂", year: 2015 },
  { title: "长安的荔枝", author: "马伯庸", year: 2021 },
  { title: "林清玄散文集", author: "林清玄", year: 1988 },
	 { title: "橘颂", author: "张炜", year: 2022 }
])
1
2
3
4
5
6
7
8
9
10
11
12
13

查找数据

在 MongoDB 中，您可以使用 find 方法来查找数据。find 方法返回满足特定查询条件的文档集合，您可以根据需要进行筛选、排序和投影。以下是一些常见的用法示例：

基本查询：

以下是一个基本的查询示例，展示如何查找所有在 “Books” 集合中的文档：

// 连接到 MongoDB 数据库
use mydatabase

// 查询 "Books" 集合中的所有文档
db.Books.find()
1
2
3
4
5

条件查询：

您可以通过传递查询条件来过滤结果。以下示例展示如何查找作者是 “鲁迅” 的书：

// 查询作者是 "鲁迅" 的书
db.Books.find({ author: "鲁迅" })
1
2

投影查询：

通过投影操作，您可以指定要返回的字段。以下示例展示如何仅返回书名和作者字段：

// 查询并投影出书名和作者字段
db.Books.find({}, { title: 1, author: 1, _id: 0 })
1
2

排序查询：

使用 sort 方法可以对结果进行排序。以下示例展示如何按年份升序排序查询结果：

// 查询并按年份升序排序
db.Books.find().sort({ year: 1 })
1
2

限制查询结果数量：

使用 limit 方法可以限制返回的文档数量。以下示例展示如何返回前三本书的数据：

// 查询并限制结果数量为三
db.Books.find().limit(3)
1
2

请注意，find 方法返回一个游标（Cursor），您可以通过迭代游标来获取查询结果。您可以使用 .toArray() 方法将游标转换为数组，或使用 forEach 循环来逐个处理结果。

更新数据

在 MongoDB 中，您可以使用 updateOne 或 updateMany 方法来更新文档。

单条更新：

以下是如何使用 updateOne 方法将 { title: "橘颂", author: "张炜", year: 2022 } 这本书的出版年份更新为 2023：

// 连接到 MongoDB 数据库
use mydatabase

// 更新指定文档的出版年份
db.Books.updateOne(
  { title: "橘颂", author: "张炜", year: 2022 },
  { $set: { year: 2023 } }
)
1
2
3
4
5
6
7
8

在上述示例中，我们使用 updateOne 方法来更新满足特定条件的文档。第一个参数是查询条件，指定要更新的文档。第二个参数使用 $set 操作符来指定要更新的字段及其新值。

多条更新：

如果您想要更新多个文档，可以使用 updateMany 方法。例如：

// 连接到 MongoDB 数据库
use mydatabase

// 更新满足条件的所有文档的出版年份
db.Books.updateMany(
  { title: "橘颂", author: "张炜", year: 2022 },
  { $set: { year: 2023 } }
)
1
2
3
4
5
6
7
8

这会将满足条件的所有文档的出版年份更新为 2023。

需要注意的是，更新操作默认只会更新匹配的第一条文档。如果您希望更新所有匹配的文档，请使用 updateMany 方法。

删除数据

在 MongoDB 中，您可以使用 deleteOne 和 deleteMany 方法来删除文档。这些方法允许您删除满足特定条件的文档，以满足您的数据管理需求。

单条删除：

使用 deleteOne 方法可以删除满足特定条件的第一条文档。以下是一个示例，展示如何使用 deleteOne 方法删除一本书：

// 连接到 MongoDB 数据库
use mydatabase

// 删除满足条件的第一条文档
db.Books.deleteOne(
  { title: "橘颂", author: "张炜", year: 2023 }
)
1
2
3
4
5
6
7

在上述示例中，我们使用 deleteOne 方法删除满足指定条件的第一条文档。

多条删除：

使用 deleteMany 方法可以删除满足特定条件的所有文档。以下是一个示例，展示如何使用 deleteMany 方法删除多本书：

// 连接到 MongoDB 数据库
use mydatabase

// 删除满足条件的所有文档
db.Books.deleteMany(
  { year: "2021" }
)
1
2
3
4
5
6
7

在上述示例中，我们使用 deleteMany 方法删除所有年份是 “2021” 的书。

上面的书都很精彩奥，个人非常推荐，大家可以多看看书，增长文化底蕴，拓宽眼界！

SpringBoot整合MongoDB

整合方式一：继承MongoRepository

在 Spring Boot 中整合 MongoDB 是相对简单的过程。Spring Boot 提供了一个名为 Spring Data MongoDB 的子项目，它大大简化了与 MongoDB 的集成。以下是在 Spring Boot 中整合 MongoDB 的基本步骤：

1. 添加依赖：
   在您的 Spring Boot 项目的 pom.xml 文件中添加以下依赖，以引入 Spring Data MongoDB：

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-mongodb</artifactId>
   </dependency>
   <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
       <scope>runtime</scope>
   </dependency>
   1
   2
   3
   4
   5
   6
   7
   8
   9

2. 配置数据库连接：
   在 application.properties 或 application.yml 配置文件中配置 MongoDB 连接信息，如数据库名称、主机和端口等：

   spring.data.mongodb.uri=mongodb://192.168.18.181:27017/my_db
   1

   yml配置

   spring:
     data:
       mongodb:
         uri: mongodb://192.168.18.181:27017/my_db
   1
   2
   3
   4

3. 创建实体类：
   创建一个 POJO（普通 Java 对象）类，表示要存储在 MongoDB 中的文档。您可以使用 Spring Data 注解来定义文档和字段映射。例如：

   import lombok.Data;
   import org.springframework.data.annotation.Id;
   import org.springframework.data.mongodb.core.mapping.Document;
   
   @Document(collection = "books")
   @Data
   public class Book {
       @Id
       private String id;
       private String title;
       private String author;
       private int year;
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

4. 创建 Repository 接口：
   创建一个继承自 org.springframework.data.mongodb.repository.MongoRepository 接口的自定义 Repository 接口。例如：

   import com.xiaohui.pojo.Book;
   import org.springframework.data.mongodb.repository.MongoRepository;
   import java.util.List;
   
   public interface BookRepository extends MongoRepository<Book, String> {
       // 可以定义自定义查询方法
       List<Book> findByAuthor(String author);
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9

5. 使用 Repository：
   在您的服务类或控制器中，注入您的自定义 Repository，并使用它来执行 MongoDB 操作。例如：

   import com.xiaohui.mapper.BookRepository;
   import com.xiaohui.pojo.Book;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   import java.util.List;
   
   @Service
   public class BookService {
       private final BookRepository bookRepository;
   
       @Autowired
       public BookService(BookRepository bookRepository) {
           this.bookRepository = bookRepository;
       }
       public List<Book> findByAuthor(String author) {
           return bookRepository.findByAuthor(author);
       }
       
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19

6.创建控制层访问接口：

import com.xiaohui.pojo.Book;
import com.xiaohui.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;

@RestController
@RequestMapping("/api")
public class BookController {

    @Autowired
    private BookService bookService;

    @GetMapping("/list")
    public HashMap<String,Object> getBookList() {
        String author = "张炜";
        HashMap<String,Object> books=new HashMap<>();
        List<Book> bookList=bookService.findBooksByAuthor(author);
        books.put("books",bookList);
        return books;
    }
}

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

整合方式二：注解MongoTemplate

如果您想在 Spring Boot 中使用 MongoTemplate 来执行 MongoDB 操作，而不是使用 MongoRepository，您可以按照以下步骤进行操作：

1. 注入 MongoTemplate：
   在您的服务类（或其他需要执行 MongoDB 操作的地方），注入 MongoTemplate：

   import org.springframework.data.mongodb.core.MongoTemplate;
   import org.springframework.stereotype.Service;
   
   @Service
   public class BookService {
       private final MongoTemplate mongoTemplate;
   
       public BookService(MongoTemplate mongoTemplate) {
           this.mongoTemplate = mongoTemplate;
       }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

2. 执行 MongoDB 操作：
   使用注入的 MongoTemplate 实例来执行 MongoDB 操作。以下是使用 MongoTemplate 执行查询的示例：

   import org.springframework.data.mongodb.core.query.Criteria;
   import org.springframework.data.mongodb.core.query.Query;
   
   
   public List<Book> findByAuthor(String author) {
       Query query = new Query(Criteria.where("author").is(author));
       return mongoTemplate.find(query, Book.class);
   }
   1
   2
   3
   4
   5
   6
   7
   8

   在上述示例中，我们使用 Criteria 来构建查询条件，然后使用 mongoTemplate.find 方法来执行查询。您可以根据需要使用不同的 Query 方法来执行查询、更新、删除等操作。

   

这样，您可以使用 MongoTemplate 来执行 MongoDB 操作，而不依赖于 MongoRepository。请注意，使用 MongoTemplate 可以提供更灵活的操作和更多的自定义能力，但也需要您手动处理更多的细节。

区别分析

MongoTemplate 和 MongoRepository 都是在 Spring Boot 中与 MongoDB 进行交互的方法，但它们有一些区别。以下是这两种方法的主要区别，我们做一个简单的了解：

1. 抽象程度和自动化：

   • MongoRepository 提供了一套高级别的抽象，使您能够通过定义接口方法来执行常见的数据库操作，如保存、查询、更新和删除等。Spring Data MongoDB 将自动实现这些方法，无需编写具体的查询代码。
   • MongoTemplate 提供了更底层的操作方式，您需要手动构建和执行查询、更新和删除操作。这提供了更大的灵活性和自定义能力，但也需要您编写更多的代码。

2. 自动化查询和条件查询：

   • MongoRepository 允许您通过方法命名约定自动生成查询。例如，通过在方法名中使用 findByAuthor，您可以自动构建查询来查找指定作者的文档。

     

   • MongoTemplate 使用 Query 和 Criteria 来构建查询，您需要手动编写查询条件和其他操作。

3. 适用场景：

   • MongoRepository 适用于那些需要执行标准化、常见查询操作的场景，特别是对于简单的CRUD操作。
   • MongoTemplate 适用于那些需要更复杂、自定义查询和操作的场景，以及那些需要更精细控制的数据库操作。

4. 复杂性和学习曲线：

   • MongoRepository 的抽象层次较高，对于开发者来说更容易上手和使用，尤其是对于基本的数据库操作。
   • MongoTemplate 提供了更多的灵活性，但需要更多的学习和了解 MongoDB 查询语法和操作。

总的来说，MongoRepository 提供了快速且易于使用的方法来执行常见的数据库操作，适用于大多数情况。MongoTemplate 则适用于那些需要更复杂操作、自定义查询和更高级的数据库操作的情况。在选择使用哪种方法时，您应该根据项目需求和开发团队的经验来进行决策。

复杂操作方式一：

多条件查询：

假设您有一个 Book 实体类，并且您想要根据多个条件进行查询，比如查找年份大于某个值且作者是某个人的书籍：

public interface BookRepository extends MongoRepository<Book, String> {
    List<Book> findByYearGreaterThanAndAuthor(int year, String author);
}
1
2
3

聚合操作：

聚合操作允许您对数据进行分组、计数、求和等操作。下面是一个示例，演示如何使用 Spring Data MongoDB 的聚合操作：

import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;

Aggregation aggregation = Aggregation.newAggregation(
    Aggregation.group("author").count().as("count"),
    Aggregation.sort(Sort.Direction.DESC, "count")
);

AggregationResults<AuthorBookCount> results = mongoTemplate.aggregate(
    aggregation, "books", AuthorBookCount.class
);
List<AuthorBookCount> authorBookCounts = results.getMappedResults();
1
2
3
4
5
6
7
8
9
10
11
12

在上述示例中，我们使用聚合操作计算每个作者的书籍数量，并按数量降序排序。

排序和分页：

您可以使用 Sort 对象来指定排序条件，使用 Pageable 对象来实现分页。

Pageable pageable = PageRequest.of(pageNumber, pageSize, Sort.by("year").descending());
Page<Book> books = bookRepository.findAll(pageable);
1
2

删除操作：

要执行删除操作，您可以使用 Spring Data MongoDB 的删除方法，根据条件进行删除。

void deleteByYearAndAuthor(int year, String author);
1

以上结合咋们目前现有的数据，展示了如何使用 MongoRepository 执行多条件查询、聚合、排序、分页和删除操作。根据具体情况，您可以使用 Spring Data MongoDB 的方法命名约定、查询构建和聚合操作来实现更复杂的操作。如果更复杂的操作无法通过方法命名约定实现，您还可以使用 @Query 注解来编写自定义的查询语句。

复杂操作方式二：

当使用 MongoTemplate 进行复杂的数据操作时，您可以通过构建查询条件、聚合管道、排序以及其他操作来实现更高级的功能。以下是几个示例，涵盖了多条件查询、聚合、排序和删除操作：

1. 多条件查询：
   假设您想要根据不同的条件来查询数据，例如查询年份大于某个值并且作者是特定作者的书籍。这里我们使用 Criteria 构建多个条件：

   Query query = new Query();
   query.addCriteria(Criteria.where("year").gt(2000).and("author").is("鲁迅"));
   List<Book> books = mongoTemplate.find(query, Book.class);
   1
   2
   3

2. 聚合操作：
   假设您想要对数据进行聚合操作，例如统计每个作者的书籍数量。这里我们使用聚合管道：

   Aggregation aggregation = Aggregation.newAggregation(
       Aggregation.group("author").count().as("bookCount")
   );
   AggregationResults<AuthorBookCount> result = mongoTemplate.aggregate(aggregation, "books", AuthorBookCount.class);
   List<AuthorBookCount> authorBookCounts = result.getMappedResults();
   1
   2
   3
   4
   5

   AuthorBookCount 是一个简单的DTO类，用于存储聚合结果。

3. 排序操作：
   假设您想要根据年份进行排序查询，可以在 Query 中添加排序选项：

   Query query = new Query();
   query.with(Sort.by(Sort.Direction.ASC, "year"));
   List<Book> books = mongoTemplate.find(query, Book.class);
   1
   2
   3

4. 删除操作：
   假设您想要删除满足特定条件的文档，可以使用 remove 方法：

   Query query = new Query();
   query.addCriteria(Criteria.where("year").lt(2000));
   mongoTemplate.remove(query, Book.class);
   1
   2
   3

MongoTemplate 还提供了更多高级功能，如更新、分页、批量操作等。这里就不一一举例，咋们自己举一反三，自己去了解！！！

好久没有更新文章了，也是最近工作有一些繁杂，导致没有时间，自己也没有兴趣去学习新的东西！今日好转，我也开始接收新的事物，将自己的学习心得与大家共享，希望大家可以受益，从此以后，所有的文章都就不再捆绑粉丝了，之前也是为了让更多的朋友看见，现在慢慢阅读量还可以，就大可不必了！希望大家学得开心，学有所获，学有所成！！！