SpringBoot使用MongoDB

已于 2024-01-29 19:07:53 修改
阅读量347 收藏 8
点赞数 7
分类专栏： SpringBoot系列基础教程 文章标签： spring boot mongodb 后端 java maven
于 2024-01-29 17:13:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laisc7301/article/details/135916832
版权

[!NOTE]

本教程是《SpringBoot系列基础教程》之一，教程目录：https://blog.csdn.net/laisc7301/article/details/135918617

首先按照图示新建项目：

在这里插入图片描述

添加以下依赖：

找到application.properties文件，并写入下面内容：

server.port=8001

spring.data.mongodb.uri=mongodb://127.0.0.1:27017/mytest

整个项目的文件结构如下图所示：

把代码贴出来，因为代码里的注释写得比较详细，这里就不多说了。

TestController.java

package com.laisc.example4.controller;

import com.laisc.example4.entity.User;
import com.mongodb.client.ListIndexesIterable;
import com.mongodb.client.model.IndexOptions;
import com.mongodb.client.model.Indexes;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import jakarta.annotation.Resource;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.springframework.data.domain.Sort;
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.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.List;


@Controller
@RequestMapping("/test")
public class TestController {

    @Resource
    private MongoTemplate mongoTemplate;

    @ResponseBody
    @RequestMapping("/create")
    public String createCollection() { //创建集合
        // 设置集合名称
        String collectionName = "test1";
        // 创建集合并返回集合信息
        mongoTemplate.createCollection(collectionName);
        // 检测新的集合是否存在，返回创建结果
        return mongoTemplate.collectionExists(collectionName) ? "创建视图成功" : "创建视图失败";
    }

    @ResponseBody
    @RequestMapping("/get1")// 执行获取集合名称列表
    public String getCollectionNames() {
        return mongoTemplate.getCollectionNames().toString();
    }

    @ResponseBody
    @RequestMapping("/get2")
    public String collectionExists() {// 检测集合是否存在
        String collectionName = "test1";//集合名
        return mongoTemplate.collectionExists(collectionName) ? "集合存在" : "集合不存在";
    }

    @ResponseBody
    @RequestMapping("/delall")
    public Object dropCollection() { //删除集合
        // 设置集合名称
        String collectionName = "test1";
        // 执行删除集合
        mongoTemplate.getCollection(collectionName).drop();
        // 检测集合是否存在，返回删除结果
        return !mongoTemplate.collectionExists(collectionName) ? "删除集合成功" : "删除集合失败";
    }

    @ResponseBody
    @RequestMapping("/insert")
    public Object insert() { // 插入文档
        // 设置用户信息
        User u = new User();
        u.setId(100);
        u.setUsername("admin");
        u.setPassword("123");
        // 插入一条用户数据，如果文档信息已经存在就抛出异常
        User u2 = mongoTemplate.insert(u, "test2");

        return u2; // 输出存储结果
    }

    @ResponseBody
    @RequestMapping("/save")
    public Object save() { // 插入文档
        // 设置用户信息
        User u = new User();
        u.setId(100);
        u.setUsername("admin");
        u.setPassword("abcd");
        // 存储用户信息,如果文档信息已经存在就执行更新
        User u2 = mongoTemplate.save(u, "test2");
        // 输出存储结果
        System.out.println("存储的用户信息为：" + u2);
        //log.info("存储的用户信息为：{}", newUser);
        return u2.toString();
    }

    /**
     * insert和save的区别
     * 插入重复数据
     *
     * 　　insert: 若新增数据的主键已经存在，则会抛 org.springframework.dao.DuplicateKeyException 异常提示主键重复，不保存当前数据。
     * 　　save: 若新增数据的主键已经存在，则会对当前已经存在的数据进行修改操作。
     * 批操作
     *
     * 　　insert: 可以一次性插入一整个列表，而不用进行遍历操作，效率相对较高
     * 　　save: 需要遍历列表，进行一个个的插入
     **/

    @ResponseBody
    @RequestMapping("/findall")
    public String findAll() { // 执行查询集合中全部文档信息
        // 执行查询集合中全部文档信息
        List<User> documentList = mongoTemplate.findAll(User.class, "test2");
        // 输出结果
        return documentList.toString();
    }

    @ResponseBody
    @RequestMapping("/findbyid")
    public String findById() { // 根据文档ID查询集合中文档数据
        // 设置查询的文档 ID
        int id = 100;
        // 根据文档ID查询集合中文档数据，并转换为对应 Java 对象
        User u = mongoTemplate.findById(id, User.class, "test2");
        return u.toString();
    }

    @ResponseBody
    @RequestMapping("/findone")
    public String findOne() { // 查询，但只输出第一条查询结果
        // 设置查询条件参数
        String username = "admin";
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is(username);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 查询一条文档，如果查询结果中有多条文档，那么就取第一条
        User user = mongoTemplate.findOne(query, User.class, "test2");

        return user.toString();
    }

    @ResponseBody
    @RequestMapping("/findmany")
    public String findByCondition() { // 查询
        // 设置查询条件参数
        String username = "admin";
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is(username);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 查询并返回结果
        List<User> documentList = mongoTemplate.find(query, User.class, "test2");

        return documentList.toString();
    }

    @ResponseBody
    @RequestMapping("/findmany2")
    public String findByCondition2() { // 查询，并按照age字段的值升序排序
        // 设置查询条件参数
        String username = "admin";
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is(username);
        // 创建查询对象，然后将条件对象添加到其中，并按照age字段的值升序排序。
        Query query = new Query(criteria).with(Sort.by("age").ascending());
        // 查询并返回结果
        List<User> documentList = mongoTemplate.find(query, User.class, "test2");

        return documentList.toString();
    }


    @ResponseBody
    @RequestMapping("/find2")
    public String findByExistsField() { //查询存在指定字段的值的文档数据
        // 设置查询条件参数
        String field = "username";
        // 创建条件
        Criteria criteria = Criteria.where(field).exists(true);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 查询并返回结果
        List<User> documentList = mongoTemplate.find(query, User.class, "test2");

        return documentList.toString();
    }

    @ResponseBody
    @RequestMapping("/update1")
    public String update() { //更新集合中【匹配】查询到的第一条文档数据，如果没有找到就【创建并插入一个新文档】
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is("admin");
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 创建更新对象,并设置更新的内容
        Update update = new Update().set("username", "root").set("password", "q123");
        // 执行更新，如果没有找到匹配查询的文档，则创建并插入一个新文档
        UpdateResult result = mongoTemplate.upsert(query, update, User.class, "test2");
        // 输出结果信息
        String resultInfo = "";
        if (result.getMatchedCount() > 0) {
            resultInfo = "匹配到1条数据,对第一条数据进行了更改";
        } else {
            resultInfo = "未匹配到数据,插入了一个新文档";
        }
        return resultInfo;
    }

    @ResponseBody
    @RequestMapping("/update2")
    public String updateFirst() {// 更新集合中【匹配】查询到的【文档数据集合】中的【第一条数据】
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is("admin");
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 创建更新对象,并设置更新的内容
        Update update = new Update().set("username", "a123").set("password", "a456");
        // 执行更新
        UpdateResult result = mongoTemplate.updateFirst(query, update, User.class, "test2");

        String resultInfo = "共匹配到" + result.getMatchedCount() + "条数据,修改了" + result.getModifiedCount() + "条数据";

        return resultInfo;
    }

    @ResponseBody
    @RequestMapping("/updatemany")
    public String updateMany() { // 更新所有符合条件的文档
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is("admin");
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 设置更新字段和更新的内容
        Update update = new Update().set("username", "root").set("password", "b123");
        // 执行更新
        UpdateResult result = mongoTemplate.updateMulti(query, update, User.class, "test2");
        // 输出结果信息
        String resultInfo = "总共匹配到" + result.getMatchedCount() + "条数据,修改了" + result.getModifiedCount() + "条数据";

        return resultInfo;
    }

    @ResponseBody
    @RequestMapping("/remove")
    public String remove() { // 执行删除匹配的全部文档信息
        // 设置查询条件参数
        int age = 30;
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is("admin").and("age").is(8);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 执行删除查找到的匹配的全部文档信息
        DeleteResult result = mongoTemplate.remove(query, "test2");
        // 输出结果信息
        String resultInfo = "成功删除 " + result.getDeletedCount() + " 条文档信息";
        return resultInfo;
    }

    @ResponseBody
    @RequestMapping("/remove2")
    public String findAndRemove() { // 执行删除查找到的匹配的第一条文档,并返回删除的文档信息
        // 创建条件对象
        Criteria criteria = Criteria.where("username").is("admin");
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 执行删除查找到的匹配的第一条文档,并返回删除的文档信息
        User result = mongoTemplate.findAndRemove(query, User.class, "test2");
        // 输出结果信息
        String resultInfo = "";
        if (result != null) {
            resultInfo = "成功删除文档信息，文档内容为：" + result.toString();
        } else {
            resultInfo = "找不到该文档。";
        }
        return resultInfo;
    }


    @ResponseBody
    @RequestMapping("/createindex")
    public String createAscendingIndex() { // 创建索引
        // 设置字段名称
        String field = "username";
        // 创建索引
        return mongoTemplate.getCollection("test2").createIndex(Indexes.ascending(field));
    }


    @ResponseBody
    @RequestMapping("/createindex2")
    public String createUniqueIndex() { // 创建唯一索引
        // 设置字段名称
        String indexName = "password";
        // 配置索引选项
        IndexOptions options = new IndexOptions();
        // 设置为唯一索引
        options.unique(true);
        // 创建索引
        return mongoTemplate.getCollection("test2").createIndex(Indexes.ascending(indexName), options);
    }

    @ResponseBody
    @RequestMapping("/getindex")
    public String getIndexAll() { // 获取集合中全部索引信息
        // 获取集合中所有列表
        ListIndexesIterable<Document> indexList = mongoTemplate.getCollection("test2").listIndexes();
        // 创建字符串集合
        List<org.bson.Document> list = new ArrayList<>();
        // 获取集合中全部索引信息
        for (org.bson.Document document : indexList) {
            list.add(document);
        }
        return list.toString();
    }

    @ResponseBody
    @RequestMapping("/removeindex")
    public String removeIndex() { // 删除集合中某个索引
        // 设置索引名称
        String indexName = "username_1";
        // 删除集合中某个索引
        mongoTemplate.getCollection("test2").dropIndex(indexName);
        return "已删除。";
    }

    @ResponseBody
    @RequestMapping("/removeindexall")
    public String removeIndexAll() { // 删除集合中全部索引
        // 删除集合中全部索引
        mongoTemplate.getCollection("test2").dropIndexes();
        return "已删除全部索引。";
    }

    @ResponseBody
    @RequestMapping("/createview")
    public Object createView() { // 创建视图
        // 设置视图名
        String newViewName = "userView";
        // 设置获取数据的集合名称
        String collectionName = "test2";
        // 定义视图的管道,可是设置视图显示的内容多个筛选条件
        List<Bson> pipeline = new ArrayList<>();
        // 设置条件，用于筛选集合中的文档数据，只有符合条件的才会映射到视图中
        pipeline.add(Document.parse("{$match:{username:'admin'}}"));
        // 执行创建视图
        mongoTemplate.getDb().createView(newViewName, collectionName, pipeline);
        // 检测新的集合是否存在，返回创建结果
        return mongoTemplate.collectionExists(newViewName) ? "创建视图成功" : "创建视图失败";
    }


    @ResponseBody
    @RequestMapping("/delall2")
    public String dropCollection2() { //之前的 dropCollection() 方法 删除【集合】，其实也可以删除【视图】
        // 设置集合名称
        String collectionName = "userView";
        // 执行删除集合
        mongoTemplate.getCollection(collectionName).drop();
        // 检测新的集合是否存在，返回删除结果
        return !mongoTemplate.collectionExists(collectionName) ? "删除视图成功" : "删除视图失败";
    }

    @ResponseBody
    @RequestMapping("/dropview")
    public Object dropView() { //删除视图，也可以是集合
        // 设置待删除的视图名称
        String viewName = "test2";
        // 检测视图是否存在
        if (mongoTemplate.collectionExists(viewName)) {
            // 删除视图
            mongoTemplate.getDb().getCollection(viewName).drop();
            return "删除视图成功";
        }
        // 检测新的集合是否存在，返回创建结果
        return !mongoTemplate.collectionExists(viewName) ? "该视图不存在" : "删除视图失败";
    }


    @ResponseBody
    @RequestMapping("/find3")
    public String findByOperator() { // 根据【逻辑运算符】查询集合中的文档数据
        // 设置查询条件参数
        int min = 4;
        int max = 8;
        // 创建条件对象
        Criteria criteria = Criteria.where("age").gt(min).lte(max);//大于4或小于等于8
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        // 查询并返回结果
        List<User> documentList = mongoTemplate.find(query, User.class, "test2");

        return documentList.toString();
    }
}

User.java

package com.laisc.example4.entity;

public class User {
    private Integer id = null;
    private String username= "";
    private String password= "";
    private Integer age = 0;
    private String role= "";

    public User() {
    }

    public User(Integer id, String username, String password, Integer age, String role) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.role = role;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", role='" + role + '\'' +
                '}';
    }
}

项目源代码下载：https://pan.baidu.com/s/11rZQUp6MOjPhCHQEvyWCwg?pwd=63mi

上一篇：SpringBoot使用MyBatis连接MySQL：https://laisc7301.github.io/blog/2024/01/07/202401070000SpringBoot%E4%BD%BF%E7%94%A8MyBatis%E8%BF%9E%E6%8E%A5MySQL/

下一篇：SpringBoot使用Redis：https://laisc7301.github.io/blog/2024/01/21/202401210000SpringBoot%E4%BD%BF%E7%94%A8Redis/

原文：https://laisc7301.github.io/blog/2024/01/12/202401120000SpringBoot%E4%BD%BF%E7%94%A8MongoDB/

睿虎
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合mongodb
07-23
mongodb版本号3.2,需手动开启http服务，启动时使用命令 ./mongod --httpinterface 新增 修改 删除 查询 排序 分页 可查看： https://blog.csdn.net/m0_37132783/article/details/96992439
SpringBoot整合MongoDB(含源代码)
热门推荐
Venus's Blog
08-03 1万+
jdk 17SpringBoot 3.1.0Mongo 6.0.8mybatis-plus 2.0.2安装教程请查看：一文搞定(linux+windows+docker)安装MongoDB 🌵application.yml配置 💡使用实例 🌵mongo 封装顶级service 🌵EmptyUtil 🌵User 🌵UserMServiceImpl 🌵MongoController 🌵测试结果
MongoDB在Spring Boot中的使用方式
Qiuban_feng的博客
02-26 1027
常见的数据存储库有很多，例如常见的Mysql、Redis、PostgreSql。但在当前敏捷开发的时代，MongoDB不需要设计数据库的结构，省去了设计步骤。在扩展时，支持水平扩展，直接添加新的服务器存储节点，使得系统能够轻松适应大规模的数据和高并发的访问。同样支持索引结构。读了下面的文章，有直截了当的例子，以及实战案例，大家可以直接Ctrl C+V，移植到在自己的代码中。另外例子中富含注释，大家只要花一些时间读一读，都会理解并且快速上手使用。
Springboot整合Mongodb（含使用案例）
最新发布
Think_and_work的博客
06-24 493
Springboot整合Mongodb
Java：SpringBoot项目中MongoTemplate的新增、删除、更新、查询操作
彭世瑜的博客
01-16 6777
多了一个_class字段，通过自定义配置类解决时间字段也不是我想要的，直接存字符串_id是ObjectId对象，直接自定义存一个uuid字符串定义配置类} }} }} }} }} }} }} }} }} }} }
MongoDB - 整合 SpringBoot 操作全流程
CYK_byte的博客
01-16 5577
uri 格式为： mongodb://ip 地址:mongodb 端口号/集合名。Ps：以 demo 集合为例。
springboot连接mongodb_MongoDB--Spring Data MongoDB详细的操作手册（增删改查）
weixin_39716417的博客
12-17 307
作者： CCWW_ 链接：https://my.oschina.net/ccwwlx/blog/3127391 在NoSQL盛行的时代，App很大可能会涉及到MongoDB数据库的使用，而也必须学会在Spring boot使用Spring Data连接MongoDB进行数据增删改查操作，如下为详细的操作手册。1. 依赖直接导入spring-data-mongodb包或者使用Spring Boot...
springboot整合mongodb changestream代码
02-23
使用Spring Data MongoDB的ChangeStream Spring Data MongoDB提供了`ChangeStreamIterable`接口，我们可以利用它来监听数据库的变化。下面是一个示例，展示了如何创建一个Change Stream并处理变更事件： ```java @...
springboot-mongodb
03-09
两种方式，一种是类似jpa的方式，使用mongodbRepository接口，可以自定义方法类似spring-data-jpa。 一种是使用MongodbOperation类提供的接口。 实现了： 增删改查，分页，批量插入，批量更新，负责条件等。
Springboot开发-将springboot与mongodb数据库相结合.zip
05-09
实体类`User`应该包含与MongoDB文档结构相对应的字段，并使用`@Document`注解标记： ```java import org.springframework.data.annotation.Id; import org.springframework.data.mongodb.core.mapping.Document; @...
springboot+mongodb
09-12
在本示例中，"springboot+mongodb" 涉及的核心知识点包括： 1. **Spring Data MongoDB**：这是 Spring Data 的一个模块，它提供了与 MongoDB 数据库交互的抽象层。通过使用 Spring Data MongoDB，你可以轻松地创建 ...
Springboot 集成 MongoDB
hjx_code的专栏
11-13 1534
在SpringBoot项目中集成MongoDB后的一些基本操作。
SpringBoot操作MongoDB数据库
m0_65563175的博客
12-29 1633
MongoTemplate开发spring-data-mongodb提供了MongoTemplate和MongoRepository两种方式访问MongoDB，MongoRepository的方式访问较为简单，MongoTemplate方式较为灵活，这两种方式在Java对于MongoDB的运用中相辅相成。
SpringBoot与MongoDB的集成使用
程序和我有一个能跑就行了
08-21 2057
MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，且与关系数据库的最为相像的......
在恰当的地方使用MongoDB的WriteConcern.SAFE参数
weixin_30794499的博客
12-01 323
首先列一下WriteConcern的几种抛出异常的级别参数： WriteConcern.NONE:没有异常抛出 WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常 WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。 WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完...
在IDEA下的MongoDB项目搭建过程，实现增删查改，springboot+MongoDB
smx6666668的博客
10-04 1422
在IDEA下的MongoDB项目搭建过程，实现增删查改，springboot+MongoDB
MongoDB入门指南：springboot整合MongoDB
dougsu的博客
05-14 5410
本文介绍了如何使用Spring Boot集成MongoDB实现对数据的增删改查操作。首先，我们简要介绍了MongoDB的基础知识，然后讲解了如何在Spring Boot项目中引入MongoDB依赖并进行配置。接下来，我们详细讲解了如何实现MongoDB的CRUD操作，并提供了实例演示。通过学习本文，读者可以了解如何使用Spring Boot和MongoDB来实现高效、灵活和可扩展的数据操作。
Spring Boot中使用MongoDB完成数据存储
好看的皮囊千篇一律，有趣的灵魂万里挑一。
11-17 1435
这篇我们将围绕MongoDB进行，MongoDB是一个开源的，面向文档的NoSQL数据库管理系统，使用类似JSON的BSON（二进制JSON）格式来存储数据，具有灵活的数据模型和强大的查询功能。 与传统的关系型数据库不同的是，MongoDB不使用表和行的结构，而是使用集合和文档进行的，一个集合就相当于关系型数据库里边的表，一个文档就相当于表中的一行数据，每个文档都是一个键值对的集合，可以包含不同类型的数据。
【MongoDB】万字长文，命令与代码一一对应SpringBoot整合MongoDB之MongoTemplate
qq_61903414的博客
08-08 2528
命令：db.comment.insert({_id:"4",nickname:"ww",content:"这位是谁啊",userId:3,createTime:……命令：db.collectionName.find({ "nickname": "ww" }).sort({ "like": 1 })命令：db.comment.find({ "like": { $gt: 0, $lt: 5 } })命令：db.comment.find({}).skip(2).limit(2)
springboot使用mongodb
06-28
### 回答1： Spring Boot可以很方便地集成MongoDB，只需要在pom.xml文件中添加MongoDB的依赖，然后在application.properties文件中配置MongoDB的连接信息即可。 具体步骤如下： 1. 在pom.xml文件中添加MongoDB的依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> ``` 2. 在application.properties文件中配置MongoDB的连接信息： ``` spring.data.mongodb.uri=mongodb://localhost:27017/mydb ``` 其中，mongodb://localhost:27017是MongoDB的连接地址，mydb是数据库名称。 3. 创建MongoDB的实体类： ``` @Document(collection = "users") public class User { @Id private String id; private String name; private int age; // 省略getter和setter方法 } ``` 其中，@Document注解表示该类对应MongoDB中的一个集合，collection属性指定集合名称；@Id注解表示该属性为MongoDB中的_id字段。 4. 创建MongoDB的Repository接口： ``` @Repository public interface UserRepository extends MongoRepository<User, String> { } ``` 其中，@Repository注解表示该接口为Spring的Repository组件；MongoRepository是Spring Data MongoDB提供的Repository接口，继承它可以获得基本的CRUD操作。 5. 在Service中使用Repository： ``` @Service public class UserService { @Autowired private UserRepository userRepository; public User save(User user) { return userRepository.save(user); } public User findById(String id) { return userRepository.findById(id).orElse(null); } public List<User> findAll() { return userRepository.findAll(); } public void deleteById(String id) { userRepository.deleteById(id); } } ``` 其中，@Autowired注解表示自动注入UserRepository；save、findById、findAll、deleteById方法分别对应MongoDB的插入、查询、查询所有、删除操作。 以上就是使用Spring Boot集成MongoDB的基本步骤。 ### 回答2： Spring Boot是一个非常流行的Java框架，它简化了Java应用程序的开发过程，并降低了应用程序的复杂性。而MongoDB是一个非关系型数据库，它以文档的形式存储数据，支持跨平台、集群等特点。Spring Boot结合MongoDB可以轻松使用非关系型数据库存储应用中的数据。下面我将介绍Spring Boot如何集成MongoDB。 1.添加MongoDB驱动 要使用MongoDB，需要添加MongoDB的驱动：mongo-java-driver。如果使用Maven，则必须在pom.xml文件中添加以下依赖关系： ``` <dependencies> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>3.6.4</version> </dependency> </dependencies> ``` 2.配置MongoDB连接信息 在application.properties文件中配置MongoDB的连接信息，示例如下： ``` spring.data.mongodb.database=mydb spring.data.mongodb.host=localhost spring.data.mongodb.port=27017 ``` 这里，我们配置了MongoDB数据库的名称、主机名和端口号。 3.创建实体类 使用MongoDB时，必须创建实体类，并将其映射到MongoDB集合中的文档。例如，以下是一个用户实体类： ``` @Document(collection = "users") public class User { @Id private String id; private String name; private int age; // getter/setter方法省略 } ``` 在这个实体类中，@Document注解用于指定集合的名称。@Id注解用于指定文档的唯一标识符。此外，还需要编写getter和setter方法。 4.创建MongoDB存储库接口 创建一个存储库接口以执行CRUD操作。以下是一个用户存储库接口示例： ``` public interface UserRepository extends MongoRepository<User, String> { User findByName(String name); List<User> findByAge(int age); } ``` 这个接口继承自MongoRepository，并定义了两个查询方法。 5.编写业务逻辑 在编写业务逻辑时，使用刚刚创建的存储库接口来保存和检索数据。以下是一个用户服务类示例： ``` @Service public class UserService { @Autowired private UserRepository userRepository; public void save(User user) { userRepository.save(user); } public User findByName(String name) { return userRepository.findByName(name); } public List<User> findByAge(int age) { return userRepository.findByAge(age); } public void delete(User user) { userRepository.delete(user); } } ``` 在这个服务类中，使用@Autowired注解注入UserRepository存储库接口。然后，使用这个接口来执行CRUD操作。 至此，我们已经学习了如何在Spring Boot中使用MongoDB。这种集成方式非常简单，适合于快速开发、原型开发或试验。如果后期需要更高的性能或更丰富的功能，可以使用更专业的非关系型数据库技术。 ### 回答3： SpringBoot是一个基于Spring框架的快速开发框架，它提供了很多开箱即用的功能，其中就包括对MongoDB的支持。MongoDB是一个NoSQL数据库，它以文档为存储单位，具有高可扩展性、高性能、易用性和开放性等优点，越来越受到开发者的青睐。 SpringBoot对MongoDB的支持，主要是通过Spring Data MongoDB来实现的。Spring Data MongoDB是Spring Data家族的一员，它提供了丰富的API和功能，让我们可以轻松地与MongoDB打交道，实现高效的数据管理和操作。 在使用SpringBoot开发MongoDB应用时，我们需要先添加MongoDB的依赖，可以在pom.xml文件中加入： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> ``` 然后，在application.properties文件中配置MongoDB的连接信息： ``` spring.data.mongodb.host=localhost spring.data.mongodb.port=27017 spring.data.mongodb.database=mydb spring.data.mongodb.username=myuser spring.data.mongodb.password=mypassword ``` 其中，host表示MongoDB的连接地址，port表示MongoDB的连接端口，database表示要使用的数据库名称，username和password表示连接MongoDB所需的用户名和密码。 接下来，我们就可以在代码中使用MongoDB了，例如： ```java @Repository public interface UserRepository extends MongoRepository<User, String> { List<User> findByFirstName(String firstName); } ``` 这段代码定义了一个UserRepository接口，它扩展自MongoRepository<User, String>，表示这是一个MongoDB数据访问接口。其中，User表示被操作的数据类型，String表示该数据类型的唯一标识。 接口中的方法findByFirstName(String firstName)表示根据firstName字段查找User数据，并返回符合条件的数据集合。 最后，我们可以在SpringBoot应用的入口类中启动MongoDB： ```java @SpringBootApplication public class MyApp { public static void main(String[] args) { SpringApplication.run(MyApp.class, args); } } ``` 这样，我们就完成了SpringBoot与MongoDB的集成和使用。使用SpringBoot和MongoDB，可以轻松地实现高效的数据管理和操作，为我们的应用开发带来很大的便利和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值