spring boot 集成mongodb

已于 2024-05-19 20:35:03 修改
阅读量246 收藏
点赞数 1
文章标签： spring mongodb java
于 2024-05-19 13:59:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ywj776199845/article/details/139041851
版权

引入依赖

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

配置db: 

spring:
  data:
    mongodb:
      host: 127.0.0.1
      database: dev-picker-db
      authentication-database: dev-picker-db
      port: 27017

在实体类上添加 @Document 并指定集合名称  @Document(collection = "customer")


import com.person.common.utils.UUIDUitl;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import java.util.Date;

@AllArgsConstructor
@Data
@Document(collection = "customer")
public class Customer {
    @Id
    private String id;
    @Indexed /**索引列**/
    private String realName;
    private String mobile;
    private Address address;
    private Date createdTime;
    private Boolean member;

    public Customer() {
        id = UUIDUitl.generateLowerString(32);
        realName = "Han";
        mobile = "13770655999";
        address = new Address();
        createdTime = new Date();
    }
    
    public static class Address {
        private String aliasName;
        private String province;
        private String city;
        private String detail;

        public Address() {
            aliasName = "Home";
            province = "JiangSu";
            city = "NanJing";
            detail = "1865";
        }
    }
    public static Customer form(String realName, String mobile, Address address) {
        Customer customer = new Customer();
        customer.realName = realName;
        customer.mobile = mobile;
        customer.address = address;
        return customer;
    }

    public static Customer form(String realName, String mobile, Address address, Boolean isMember) {
        Customer customer = new Customer();
        customer.realName = realName;
        customer.mobile = mobile;
        customer.address = address;
        customer.member = isMember;
        return customer;
    }
    

}

编写测试类 


import com.bmyg.api.mongo.Customer;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RequestMapping("/uncontrol/mongo")
@RestController
public class MongoDBController {

    @Resource
    private MongoTemplate mongoTemplate;


    @GetMapping("/test")
    public String getMongoDBName() {
        Customer customer = new Customer();
        mongoTemplate.insert(customer);
        return mongoTemplate.getDb().getName();
    }

}

结果:

其他查询：

package com.test.api;

import com.alibaba.fastjson.JSON;
import com.test.api.mongo.Customer;
import com.test.api.mongo.CustomerRepository;
import com.test.api.mongo.CustomerVo;
import com.test.api.mongo.PageResult;
import com.mongodb.client.ListIndexesIterable;
import org.bson.Document;
import org.springframework.beans.BeanUtils;
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.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;

@RequestMapping("/uncontrol/mongo")
@RestController
public class MongoDBController {

    @Resource
    private MongoTemplate mongoTemplate;

    @Resource
    private CustomerRepository customerRepository;



    //给customer集合的某个字段创建索引
    @GetMapping("/crtIdx")
    public String createIndex(@RequestParam String key) {
        Index index = new Index(key, Sort.Direction.ASC);
        mongoTemplate.indexOps("customer").ensureIndex(index);
        return "ok";
    }


    //获取所有集合
    @GetMapping("/coll")
    public Set<String> index() {
        return mongoTemplate.getCollectionNames();
    }

    //插入
    @GetMapping("/insert")
    public String insert() {
        Customer customer = new Customer();
        mongoTemplate.insert(customer);
        return mongoTemplate.getDb().getName();
    }

    //查询
    @PostMapping("/query")
    public String query(@RequestBody Customer cus) {

        //查询所有
        List<Customer> result = mongoTemplate.findAll(Customer.class);
        System.out.println("查询所有" + JSON.toJSONString(result));

        //通过ID 查询
        Customer byId = mongoTemplate.findById(cus.getId(), Customer.class);
        System.out.println("通过ID 查询" + JSON.toJSONString(byId));
        Query query = new Query(Criteria.where("realName").is(cus.getRealName()));


        //条件-精确查询，返回第一条数据，没有条件 依旧会查询数据，但是返回第一条
        Customer findOne = mongoTemplate.findOne(query, Customer.class);
        System.out.println("条件-精确查询，返回第一条数据" + JSON.toJSONString(findOne));


        //条件-精确查询，返回所有数据---没有条件 依旧会查询数据，返回所有
        List<Customer> findList = mongoTemplate.find(query, Customer.class);
        System.out.println("条件-精确查询，返回所有数据" + JSON.toJSONString(findList));

        return JSON.toJSONString(result);
    }

    //删除
    @PostMapping("/del")
    public String del(@RequestBody Customer cus) {
        Query query = new Query(Criteria.where("realName").is(cus.getRealName()));
        mongoTemplate.remove(query, Customer.class);
        return mongoTemplate.getDb().getName();
    }

    //查询所有索引
    @PostMapping("/all-idx")
    public String getIndexAll() {
        // 获取集合中所有列表---import org.bson.Document;
        ListIndexesIterable<Document> indexList =
                mongoTemplate.getCollection("customer").listIndexes();
        StringBuilder sb = new StringBuilder();
        // 获取集合中全部索引信息
        for (Document document : indexList) {
            sb.append(document + "/r/n");
        }
        return sb.toString();
    }


    //模糊查询
    @PostMapping("/like-query")
    public String likequery(@RequestBody Customer cus) {
        //模糊查询
        Query queryLike = new Query(Criteria.where("realName").regex(".*" + cus.getRealName() + ".*"));
        List<Customer> queryLikeResult = mongoTemplate.find(queryLike, Customer.class);
        System.out.println(queryLikeResult);
        return JSON.toJSONString(queryLikeResult);
    }


    //多条件查询 and
    @PostMapping("/query-and")
    public String manyMatchAnd(@RequestBody Customer cus) {
        //多条件查询
        Criteria criteriaUserName = Criteria.where("realName").is(cus.getRealName());
        Criteria criteriaPassWord = Criteria.where("mobile").is(cus.getMobile());
        // 创建条件对象，将上面条件进行 AND 关联
        Criteria criteria = new Criteria().andOperator(criteriaUserName, criteriaPassWord);
        Query queryLike = new Query(criteria);
        List<Customer> queryLikeResult = mongoTemplate.find(queryLike, Customer.class);
        return JSON.toJSONString(queryLikeResult);
    }

    //多条件查询 or
    @PostMapping("/query-or")
    public String manyMatchOr(@RequestBody Customer cus) {
        Criteria criteriaUserName = Criteria.where("realName").is(cus.getRealName());
        Criteria criteriaPassWord = Criteria.where("mobile").is(cus.getMobile());
        // 创建条件对象，将上面条件进行 OR 关联
        Criteria criteria = new Criteria().orOperator(criteriaUserName, criteriaPassWord);
        Query queryor = new Query(criteria);
        List<Customer> queryLikeResult = mongoTemplate.find(queryor, Customer.class);
        return JSON.toJSONString(queryLikeResult);
    }

    //多条件查询 in
    @PostMapping("/query-in")
    public String findByInCondition() {
        // 设置查询条件参数
        List<String> names = Arrays.asList("Ma", "liu", "li");
        // 创建条件-- 创建条件，in 后面是list 集合
        Criteria criteria = Criteria.where("realName").in(names);
        // 创建查询对象，然后将条件对象添加到其中
        Query queryIn = new Query(criteria);
        List<Customer> result = mongoTemplate.find(queryIn, Customer.class);
        return JSON.toJSONString(result);
    }

    
    //根据【逻辑运算符】查询集合中的文档数据
    @PostMapping("/query-gt")
    public String findByGt() {
        int min = 20;
        int max = 35;
        Criteria criteria = Criteria.where("age").gt(min).lte(max);
        // 创建查询对象，然后将条件对象添加到其中
        Query queryGt = new Query(criteria);
        List<Customer> result = mongoTemplate.find(queryGt, Customer.class);
        return JSON.toJSONString(result);
    }




    //根据【正则表达式】查询集合中的文档数据
    @PostMapping("/query-regex")
    public String findByRegex() {
        String regex = "^张*";
        Criteria criteria = Criteria.where("realName").regex(regex);
        // 创建查询对象，然后将条件对象添加到其中
        Query queryRegex = new Query(criteria);
        List<Customer> result = mongoTemplate.find(queryRegex, Customer.class);
        return JSON.toJSONString(result);
    }

    //更新
    @PostMapping("/update")
    public String update(@RequestBody Customer cus) {
        Query query = new Query(Criteria.where("mobile").is(cus.getMobile()));
        Update update = new Update().set("realName", cus.getRealName());
        mongoTemplate.updateMulti(query, update, Customer.class);
        return mongoTemplate.getDb().getName();
    }
    
    // 分页查询---逻辑没问题 序列化有问题！！！！！！！！！！！！！！！！！
    @PostMapping("/query-page")
    public PageResult<Customer> queryPage(@RequestBody CustomerVo customerVo) {
        Customer cus = new Customer();
        BeanUtils.copyProperties(customerVo, cus);
        Query queryLike = new Query(Criteria.where("realName").regex(".*" + cus.getRealName() + ".*"));
        long total = mongoTemplate.count(queryLike, Customer.class);
        Integer skip = (customerVo.getPageNo() - 1) * customerVo.getPageSize();
        queryLike.skip(skip).limit(customerVo.getPageSize());
        queryLike.with(Sort.by(Sort.Order.desc("createdTime")));
        List<Customer> findList = mongoTemplate.find(queryLike, Customer.class);
        return PageResult.pageResult(customerVo.getPageNo(), customerVo.getPageSize(), (int) total, findList);
    }


}

其他：


import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.person.common.utils.UUIDUitl;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;

import java.util.Date;

@AllArgsConstructor
@Data
@Document(collection = "customer")
public class Customer {
    @Id
    private String id;
    @Indexed
    private String realName;
    private String mobile;
    @JsonIgnoreProperties(ignoreUnknown = true)
    private Address address;
    private Date createdTime;
    private Boolean member;
    private int age;

    public Customer() {
        id = UUIDUitl.generateLowerString(32);
        realName = "Han";
        mobile = "13770655999";
        address = new Address();
        createdTime = new Date();
        age = 18;
    }

    public static class Address {
        private String aliasName;
        private String province;
        private String city;
        private String detail;

        public Address() {
            aliasName = "Home";
            province = "JiangSu";
            city = "NanJing";
            detail = "1865";
        }
    }

    public static Customer form(String realName, String mobile, Address address) {
        Customer customer = new Customer();
        customer.realName = realName;
        customer.mobile = mobile;
        customer.address = address;
        return customer;
    }

    public static Customer form(String realName, String mobile, Address address, Boolean isMember) {
        Customer customer = new Customer();
        customer.realName = realName;
        customer.mobile = mobile;
        customer.address = address;
        customer.member = isMember;
        return customer;
    }


}

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.Date;

/**
 *
 * @version JDK 11
 * @className CustomerVo
 * @description TODO
 */

@AllArgsConstructor
@Data
public class CustomerVo {

    private String id;
    private String realName;
    private String mobile;

    private Date createdTime;
    private Boolean member;
    private int age;
    private Integer pageNo;
    private Integer pageSize;


}


import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import org.hibernate.validator.constraints.Range;

import javax.validation.constraints.NotNull;
import java.io.Serializable;


@Data
@ApiModel
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class PageQuery implements Serializable {

    @ApiModelProperty(value = "页码，默认1", example = "1")
    @NotNull(message = "页码不能为空")
    @Range(min = 1, message = "页码不正确")
    protected Integer pageNo = 1;

    @ApiModelProperty(value = "每页条数, 默认10", example = "10")
    @NotNull(message = "每页条数不能为空")
    protected Integer pageSize = 10;

    /**
     * 偏移
     */
    @ApiModelProperty(hidden = true)
    protected Integer offset;

    public Integer getOffset() {
        return (getPageNo() - 1) * getPageSize();
    }

    public Integer getPageNo() {
        return pageNo == null ? 1 : pageNo;
    }

    public Integer getPageSize() {
        return pageSize == null ? 10 : pageSize;
    }
}


import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;
import java.util.Collections;
import java.util.List;

@Data
@ApiModel(description = "分页数据返回模型")
public class PageResult<T> implements Serializable {
    @ApiModelProperty(value = "当前页 - 和PageQuery保持统一")
    private Integer pageNo;

    @Deprecated
    @ApiModelProperty(value = "当前页", hidden = true)
    private Integer page;

    @ApiModelProperty(value = "每页条数")
    private Integer pageSize;

    @ApiModelProperty(value = "总记录数")
    private Integer total;

    @ApiModelProperty(value = "查询数据")
    private List<T> list;

    public Integer getPageNo() {
        return pageNo;
    }

    public void setPageNo(Integer pageNo) {
        this.pageNo = pageNo;
        this.page = pageNo;
    }

    @Deprecated
    public Integer getPage() {
        return page;
    }

    @Deprecated
    public void setPage(Integer page) {
        this.page = page;
        this.pageNo = page;
    }

    public static <T> PageResult<T> pageResult(Integer page, Integer pageSize, Integer total, List<T> list) {
        PageResult<T> pageResult = new PageResult<T>();
        pageResult.setPage(page);
        pageResult.setPageNo(page);
        pageResult.setPageSize(pageSize);
        pageResult.setList(list);
        pageResult.setTotal(total);
        return pageResult;
    }

    public static <T> PageResult<T> pageResult(PageQuery query, Integer total, List<T> list) {

        return pageResult(query.getPageNo(), query.getPageSize(), total, list);
    }

    public static <T> PageResult<T> pageResult(PageQuery query, long total, List<T> list) {

        return pageResult(query.getPageNo(), query.getPageSize(), (int) total, list);
    }

    //    public static <T> PageResult<T> pageResultLimit( PageQuery query, long total, List<T> list ) {
//        if (total>10000L){
//            total=10000L;
//        }
//        return pageResult(query.getPageNo(), query.getPageSize(), (int) total, list);
//    }
    public static <T> PageResult<T> empty(PageQuery query) {
        return pageResult(query, 0, Collections.emptyList());
    }

    /**
     * 获取总页数
     *
     * @return 总页数
     */
    @JsonIgnore
    @ApiModelProperty(hidden = true)
    public Integer getPages() {
        if (getPageSize() == 0) {
            return 0;
        }
        int pages = getTotal() / getPageSize();
        if (getTotal() % getPageSize() != 0) {
            pages++;
        }
        return pages;
    }

}

土耳其的烧烤
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot集成mongodb数据库过程解析
08-19
主要介绍了Spring Boot集成mongodb数据库过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Boot无缝集成MongoDB
08-30
主要介绍了Spring Boot无缝集成MongoDB的相关知识，本文涉及到MongoDB的概念和nosql的应用场景,需要的朋友可以参考下
Spring Boot使用MongoDB详解
02-22
本文将详细介绍如何在Spring Boot项目中集成MongoDB数据库，包括其原理、使用流程、步骤以及完整的代码示例。通过本文，读者将能够了解Spring Boot与MongoDB的集成方式，掌握在Spring Boot应用程序中操作MongoDB数据库的基本方法。 随着大数据时代的到来，NoSQL数据库因其灵活的数据模型和高性能的特点逐渐受到开发者的青睐。MongoDB作为NoSQL数据库中的一种，以其面向文档的存储方式、高效的查询性能以及丰富的查询语言而著称。Spring Boot作为一个快速构建应用的框架，提供了对MongoDB的良好支持。 MongoDB是一个基于分布式文件存储的数据库，由C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。它介于关系数据库和非关系数据库之间，是非关系数据库当中功能最丰富、最像关系数据库的。MongoDB的数据结构非常松散，采用类似JSON的BSON格式，因此可以存储比较复杂的数据类型。
Sprint Boot 集成MongoDB的操作方法
08-28
最近接手一个Springboot项目，需要在原项目上增加一些需求，用到了mongodb。下面通过本文给大家分享Sprint Boot 集成MongoDB的操作方法，需要的朋友参考下吧
springboot整合mongodb
07-23
mongodb版本号3.2,需手动开启http服务，启动时使用命令 ./mongod --httpinterface 新增 修改 删除 查询 排序 分页 可查看： https://blog.csdn.net/m0_37132783/article/details/96992439
Spring Boot 集成 MongoDB 简单使用
TechnicianWang的博客
09-13 1319
用户信息(注意观察 [ _id, db, roles -> db ] 这三个值是否和我们创建的db匹配)如果用户信息与数据库信息匹配上了我们就可以在配置文件内配置mongodb信息。创建用户(如果不在指定数据库下创建，默认为test数据库下的用户信息)前换到admin数据库，查看是否有刚才数据库下创建的用户信息。二.在application.yml配置mongodb。数据库：db_mydbtest。创建数据库或者在指定数据库下。五.service实现类。四.Mapper接口。
Spring boot集成mongoDB使用MongoRepository
程序员路同学
05-16 1759
引入依赖 springboot集成MongoDb引入依赖 <!--spring data mongodb--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> 看一下MongoReposit
三、Spring boot集成mongodb
qq_43102730的博客
05-21 3474
spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongodb，MongoRepository操作简单，MongoTemplate操作灵活，我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足。
Spring Boot集成MongoDB
weixin_51364443的博客
07-07 811
集成简介 spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongoDB（都能对mongoDB进行CRUD操作），MongoRepository操作简单，MongoTemplate操作灵活，我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足。 搭建开发环境 初始化工程 使用 Spring Initializr 快速初始化一个 Sprin
spring boot 集成 mongodb
Ethe的博客
11-23 176
原文地址：https://www.cnblogs.com/okong/p/springboot-thirty-one.html mongodb 的安装 下载地址：https://fastdl.mongodb.org/win32/mongodb-win32-x86_64-2008plus-ssl-4.0.3-signed.msi 下载结束后 安装就好 开始集成 加入POM依赖 <depen...
6、Spring之Bean生命周期~创建Bean（2）
sproutBoy的博客
06-10 677
【代码】6、Spring之Bean生命周期~创建Bean（2）
springboot与flowable（2）：流程部署
游王子的博客
06-10 281
选择建模器应用程序选择要导出的建模点击导出按钮。将导出的文件复制到项目中。
SpringCloud之Zuul源码解析
qq_36851469的博客
06-10 233
Zuul 是在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。Zuul 可以适当的对多个 Amazon Auto Scaling Groups 进行路由请求。其架构如下图所示：Zuul提供了一个框架，可以对过滤器进行动态的加载，编译，运行。过滤器之间没有直接的相互通信。他们是通过一个RequestContext的静态类来进行数据传递的。
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 921
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
JAVA学习笔记DAY5——SSM_Spring
最新发布
weixin_47227105的博客
06-13 391
Spring Ioc容器是复杂容器。一个项目project拆分成多个模块module。配置方式包括三种：xml、注解、配置类。从文件结构的角度看，框架=jar包+是SSM的一种简化，快速创建服务。用来维护不同服务的相互调用。控制层组件 Servlet。业务逻辑层 Service。持久化层组件 Dao。
SpringBoot项目启动提示端口号占用
点滴汇聚，智在积累。——Danny
06-07 230
通过netstat查看当前端口号并没有被占用啊，那可能是使用了系统保留端口，通过。1、换个端口（不在系统保留端口的范围）于是换个端口号试试，还是提示占用。2、关闭hyper-v。
springboot连接多个库
sunyingboaini的博客
06-11 169
一个SpringBoot项目，同时连接两个数据库：比如一个是Mysql数据库，一个是oracle数据库（啥数据库都一样，连接两个同为oracle的数据库，或两个不同的数据库，只需要更改对应的driver-class-name和jdbc-url等即可）注意：连接什么数据库，要引入对应数据库的包。
springBoot多数据源使用、配置
qx020814的博客
06-12 275
又参加了一个新的项目，虽然是去年做的项目，拿来复用改造，但是也学到了很多。这个项目会用到其他项目的数据，如果调用他们的接口取数据，我还是觉得太麻烦了。打算直接配置多数据源。使用@DS("数据源名称") ，就能指定使用某一个数据源。就是配置两个数据库信息，后续使用@DS("数据源名称")配置了druid之后，项目运行起来就能访问,然后去另一个数据库系统中取出数据。,可以看见有两个数据源可以使用。所以就去了解和学习了一下。
SpringBootWeb 篇-深入了解 AOP 面向切面编程与 AOP 记录操作日志案例
小扳手
06-07 1636
AOP，Aspect Oriented Programming 面向切面编程，在 AOP 中，横切关注点被称为切面（Aspect），切面通过特定的注入方式被应用到程序的不同部分，从而实现对这些部分的增强或修改。AOP 能够帮助开发者更好地管理程序的复杂性，提高代码的重用性和易读性。简单来说，就是面向特定的方法编程，也或者说给原始的方法进行升级改造。这样原始的方法就不需要进行改变，从而实现方法升级了。如日志记录、权限控制等功能。通过AOP，可以实现方法的升级改造，提高代码的可维护性和可重用性。
spring boot druid mongodb
10-23
Spring Boot是一个用于构建Java应用程序的框架，它能够简化开发过程，提高生产力。它通过提供一系列的开箱即用的特性和配置，允许我们快速构建可运行的、独立的Spring应用程序。 Druid是一个开源的Java数据库连接池框架，它提供了一组可扩展的API，用于管理和监控数据库连接。Druid具有优秀的性能和丰富的扩展功能，可以有效地管理大量的数据库连接。 MongoDB是一个开源的文档数据库，它使用JSON风格的文档格式存储数据。MongoDB具有高可用性、可扩展性和灵活的数据模型，适用于许多不同类型的应用程序。 Spring Boot与Druid和MongoDB的结合可以带来一些好处。首先，Druid可以作为Spring Boot应用程序的数据库连接池，提供高性能和高可用性的数据库连接管理。它可以监控和管理数据库连接的使用情况，避免连接泄漏和过多的连接创建。 其次，Spring Boot与MongoDB的集成使得开发人员能够轻松地使用MongoDB作为应用程序的数据存储。Spring Boot提供了与MongoDB的无缝集成，简化了数据访问的配置和操作。 最后，Spring Boot、Druid和MongoDB的集成可以帮助开发人员更好地应对大规模的数据存储和处理需求。Druid的连接池管理功能可以提高应用程序的性能和可靠性，而MongoDB的扩展性和灵活性可以满足不同类型的数据存储需求。 综上所述，Spring Boot、Druid和MongoDB的结合可以提供高性能、高可用性和灵活的数据存储和管理解决方案，适用于各种类型的Java应用程序开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值