SpringBoot整合MongoDB

举报
哥的时代 发表于 2023/12/26 23:30:22 2023/12/26
【摘要】 前言 了解Spring Data。Spring Data 是 Spring 框架的一个子项目，旨在简化与各种数据存储技术（如关系型数据库、NoSQL数据库、图数据库等）的集成和操作。它提供了一种统一的编程模型和API，使开发人员能够以一致的方式访问和操作不同类型的数据存储。Spring Data 通过提供通用的 CRUD 操作、查询方法、事务管理和数据访问抽象层等功能，简化了数据访问层的开...

前言

了解Spring Data。

Spring Data 是 Spring 框架的一个子项目，旨在简化与各种数据存储技术（如关系型数据库、NoSQL数据库、图数据库等）的集成和操作。它提供了一种统一的编程模型和API，使开发人员能够以一致的方式访问和操作不同类型的数据存储。Spring Data 通过提供通用的 CRUD 操作、查询方法、事务管理和数据访问抽象层等功能，简化了数据访问层的开发工作。它还提供了与 Spring 框架其他模块（如Spring Boot、Spring MVC等）的无缝集成，使开发人员能够更轻松地构建全栈应用程序。

官网地址：https://springdoc.cn/spring-data/

一、环境搭建

1、引入依赖

<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.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
    </dependencies>

2、编写配置文件

# mongodb 没有开启任何安全协议
# mongodb(协议)://192.168.10.130(主机):27017(端口)/gedeshidai(库名)
spring.data.mongodb.uri=mongodb://192.168.10.130:27017/gedeshidai

# mongodb 存在密码
#spring.data.mongodb.host=192.168.10.130
#spring.data.mongodb.port=27017
#spring.data.mongodb.database=gedeshidai
#spring.data.mongodb.username=root
#spring.data.mongodb.password=root

二、集合

1、创建集合

@Test
 public void testCreateCollection(){
   mongoTemplate.createCollection("users");//参数: 创建集合名称
 }

注意: 创建的集合已经存在时，再次创建会报错，因此创建前需要判断集合时候已经存在

/**
  * 创建集合
  */
 @Test
 public void testCreateCollection(){
     // 判断集合是否存在
     boolean isExist = mongoTemplate.collectionExists("products");
     // 不存在时创建集合
     if (!isExist) {
         mongoTemplate.createCollection("products");
     }
 }

2、删除集合

/**
  * 删除集合
  */
 @Test
 public void testDropCollection(){
     mongoTemplate.dropCollection("products");
 }

三、文档

1、相关注解

  • @Document 对应 类

    • 修饰范围: 用在类上

    • 作用: 用来映射这个类的一个对象为 mongo 中一条文档数据

    • 属性：(value 、collection )用来指定操作的集合名称

  • @Id 对应 要指定为_id的变量名

    • 修饰范围: 用在成员变量、方法上，只能出现一次

    • 作用： 用来将成员变量的值映射为文档的_id 的值

  • @Field 对应 剩余变量名（变量名都按照类中属性名定义时，可以不指定，即同名时可不指定）

    • 修饰范围: 用在成员变量、方法上

    • 作用: 用来将成员变量以及值映射为文档中一个key、value对

    • 属性: ( name,value)用来指定在文档中 key 的名称,默认为成员变量名

  • @Transient 不参与文档转换

    • 修饰范围: 用在成员变量、方法上

    • 作用 : 用来指定改成员变量，不参与文档的序列化

2、文档操作

2.1、查询

  • Criteria
    image.png

  • 常见查询

@Test
 public void testQuery(){
   //基于 id 查询
   template.findById("1",User.class);
 ​
   //查询所有
   template.findAll(User.class);
   template.find(new Query(),User.class);
 ​
   //等值查询
   template.find(Query.query(Criteria.where("name").is("哥的时代")), 
                User.class);
 ​
   // > gt  < lt  >= gte  <= lte
   template.find(Query.query(Criteria.where("age").lt(25)),
                 User.class);
   template.find(Query.query(Criteria.where("age").gt(25)),
                 User.class);
   template.find(Query.query(Criteria.where("age").lte(25)),
                 User.class);
   template.find(Query.query(Criteria.where("age").gte(25)),
                 User.class);
 ​
   //and
   template.find(Query.query(Criteria.where("name").is("哥的时代")
                             .and("age").is(23)),User.class);
 ​
   //or
   Criteria criteria = new Criteria()
     .orOperator(Criteria.where("name").is("哥的时代_1"),
      Criteria.where("name").is("哥的时代_2"));
   template.find(Query.query(criteria), User.class);
 ​
   //and or
   Criteria criteria1 = new Criteria()
     .and("age").is(23)
     .orOperator(
     Criteria.where("name").is("哥的时代_1"),
     Criteria.where("name").is("哥的时代_2"));
   template.find(Query.query(criteria1), User.class);
 ​
   //sort 排序
   Query query = new Query();
   query.with(Sort.by(Sort.Order.desc("age")));//desc 降序  asc 升序
   template.find(query, User.class);
 ​
 ​
   //skip limit 分页
   Query queryPage = new Query();
   queryPage.with(Sort.by(Sort.Order.desc("age")))//desc 降序  asc 升序
     .skip(0) //起始条数
     .limit(4); //每页显示记录数
   template.find(queryPage, User.class);
 ​
 ​
   //count 总条数
   template.count(new Query(), User.class);
 ​
   //distinct 去重
   //参数 1:查询条件 参数 2: 去重字段  参数 3: 操作集合  参数 4: 返回类型
   template.findDistinct(new Query(), "name", 
                         User.class, String.class);
   
   //使用 json 字符串方式查询 
         Query query = new BasicQuery(
           "{$or:[{name:'哥的时代'},{name:'徐凤年'}]}", 
           "{name:0}");
 ​
   template.find(query, User.class);
 }

2.2、添加

@Test
 public void testSaveOrUpdate(){
   User user = new User();
   user.setId("1");
   user.setAge(23);
   user.setName("哥的时代_1");
   user.setBir(new Date());
   User userDB = mongoTemplate.insert(user);//返回保存的对象 insert or save
   System.out.println(userDB);
 }

  • 插入重复数据时：

    • insert报DuplicateKeyException提示主键重复；

    • save对已存在的数据进行更新。

  • 批处理操作时：

    • insert可以一次性插入整个数据，效率较高；

    • save需遍历整个数据，一次插入或更新，效率较低。

2.3、更新

@Test
 public void  testUpdate(){
   //1.更新条件
   Query query = Query.query(Criteria.where("age").is(23));
   //2.更新内容
   Update update = new Update();
   update.set("name","哥的时代");
 ​
   //单条更新
   mongoTemplate.updateFirst(query, update, User.class);
   //多条更新
   mongoTemplate.updateMulti(query, update, User.class);
   //更新插入
   mongoTemplate.upsert(query,update,User.class);
 ​
   //返回值均为 updateResult
   //System.out.println("匹配条数:" + updateResult.getMatchedCount());
   //System.out.println("修改条数:" + updateResult.getModifiedCount());
   //System.out.println("插入id_:" + updateResult.getUpsertedId());
 }

2.4、删除

@Test
 public void testDelete(){
   //删除所有
   mongoTemplate.remove(new Query(),User.class);
   //条件删除
   mongoTemplate.remove(
     Query.query(Criteria.where("name").is("哥的时代")),
     User.class
   );
 }

四、整合

1、pom.xml依赖

    <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.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <!--lombok-->
 		<dependency>
     		<groupId>org.projectlombok</groupId>
     		<artifactId>lombok</artifactId>
		</dependency>
    </dependencies>

2、application.properties配置


# mongodb 没有开启任何安全协议
# mongodb(协议)://192.168.10.130(主机):27017(端口)/gedeshidai(库名)
spring.data.mongodb.uri=mongodb://192.168.10.130:27017/gedeshidai

# mongodb 存在密码
#spring.data.mongodb.host=192.168.10.130
#spring.data.mongodb.port=27017
#spring.data.mongodb.database=gedeshidai
#spring.data.mongodb.username=root
#spring.data.mongodb.password=root

3、实体类User

package com.study.entity;
 ​
 import lombok.*;
 import lombok.experimental.Accessors;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.Field;
 ​
 import java.util.Date;
 ​
 @Data
 @Accessors(chain = true)
 @Document(value = "users")
 public class User {
     @Id
     private Integer id;
 ​
     @Field(value = "username")
     private String name;
 ​
     @Field
     private Double salary;
 ​
     @Field
     private Date birthday;
 }

4、测试类

package com.study.test;
 ​
 import com.mongodb.client.result.DeleteResult;
 import com.mongodb.client.result.UpdateResult;
 import com.study.entity.User;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 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 java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 ​
 @SpringBootTest
 public class MongodbTest {
     @Autowired
     private MongoTemplate mongoTemplate;
 ​
     /**
      * 创建集合
      */
     @Test
     public void testCreateCollection() {
         // 判断集合是否存在
         boolean isExist = mongoTemplate.collectionExists("products");
         // 不存在时创建集合
         if (!isExist) {
             mongoTemplate.createCollection("products");
         }
     }
 ​
     /**
      * 删除集合
      */
     @Test
     public void testDropCollection() {
         mongoTemplate.dropCollection("products");
     }
 ​
     /**
      * 添加单个文档1
      */
     @Test
     public void testSaveDocument() {
         User user = new User();
         user.setId(1)
                 .setName("熊大")
                 .setSalary(800.0)
                 .setBirthday(new Date());
         mongoTemplate.save(user);
     }
 ​
     /**
      * 添加单个文档2
      */
     @Test
     public void testAddDocument() {
         User user = new User();
         user.setId(2)
                 .setName("熊二")
                 .setSalary(500.0)
                 .setBirthday(new Date());
         mongoTemplate.insert(user);
     }
 ​
     /**
      * 批量添加文档
      */
     @Test
     public void testBatchInsertDocument() {
         List<User> userList = new ArrayList<>();
         userList.add(new User().setId(6).setName("猪猪侠").setSalary(1000.0).setBirthday(new Date()));
         userList.add(new User().setId(7).setName("小呆呆").setSalary(600.0).setBirthday(new Date()));
         userList.add(new User().setId(8).setName("波比").setSalary(50.0).setBirthday(new Date()));
 //        mongoTemplate.insert(userList, User.class);
         // 上下两种方式均可，上面指定类名，下面指定集合名
         mongoTemplate.insert(userList, "users");
     }
 ​
     /**
      * 查询操作
      */
     @Test
     public void testFind() {
         // 1.查询所有
         List<User> users = mongoTemplate.findAll(User.class, "users");
         users.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 或
         List<User> userList = mongoTemplate.findAll(User.class);
         userList.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 2.基于id查一个
         User user = mongoTemplate.findById(1, User.class, "users");
         System.out.println(user);
 ​
         System.out.println();
 ​
         // 或
         User user2 = mongoTemplate.findById(1, User.class);
         System.out.println(user2);
 ​
         System.out.println();
 ​
         // 3.条件查询
         // 3.1 查询所有
         List<User> users2 = mongoTemplate.find(
                 new Query(), User.class, "users"
         );
         users2.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 或
         List<User> usersList2 = mongoTemplate.find(
                 new Query(), User.class
         );
         usersList2.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 3.2 等值查询：注意值要写对类型，例如不要将Integer写成String
         List<User> users3 = mongoTemplate.find(
                 new Query(Criteria.where("salary").is(600)), User.class
         );
         users3.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 3.3 不等值查询
         List<User> users1 = mongoTemplate.find(
                 new Query().addCriteria(Criteria.where("salary").gt(800)), User.class
         );
         users1.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 3.4 and查询
         List<User> users4 = mongoTemplate.find(
                 new Query().addCriteria(Criteria.where("salary").gt(800).and("name").is("光头强")), User.class
         );
         users4.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 3.5 or查询
         List<User> users5 = mongoTemplate.find(
                 new Query().addCriteria(
                         new Criteria().orOperator(
                                 Criteria.where("salary").gt(800),
                                 Criteria.where("name").is("小呆呆"))),
                 User.class
         );
         users5.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 3.6 and、or查询连用
         List<User> users6 = mongoTemplate.find(
                 new Query().addCriteria(
                                 new Criteria().orOperator(
                                         Criteria.where("name").in("光头强", "小呆呆")))
                         .addCriteria(Criteria.where("salary").is(600)), User.class
         );
         users6.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 4.排序
         List<User> users7 = mongoTemplate.find(
                 new Query().with(Sort.by(Sort.Order.desc("salary"))), User.class
         );
         users7.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 5.排序后分页
         List<User> users8 = mongoTemplate.find(
                 new Query().with(Sort.by(Sort.Order.asc("salary")))
                         .skip(0)
                         .limit(2), User.class
         );
         users8.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 6.查询总条数
         long count = mongoTemplate.count(new Query(), User.class);
         System.out.println("count = " + count);
 ​
         System.out.println();
 ​
         // 7.去重
         List<Double> salaryList = mongoTemplate.findDistinct(new Query(), "salary", User.class, Double.class);
         salaryList.forEach(System.out::println);
 ​
         System.out.println();
 ​
         // 8.使用json字符串方式查询
         Query query = new BasicQuery("{$or: [{name:'小呆呆'},{name:'光头强'}]}", "{birthday:0}");
         List<User> users9 = mongoTemplate.find(
                 query, User.class
         );
         users9.forEach(System.out::println);
     }
 ​
     /**
      * 更新文档
      */
     @Test
     public void testUpdateDocument() {
         Update update = new Update();
         update.set("salary", 2500);
         // 更新一条
         mongoTemplate.updateFirst(
                 Query.query(Criteria.where("salary").is(1000)),
                 update,
                 User.class);
 ​
         update.set("salary", 1500);
         // 更新多条
         mongoTemplate.updateMulti(
                 Query.query(Criteria.where("salary").lt(200)),
                 update,
                 User.class
         );
 ​
         // 插入更新
         update.setOnInsert("id", 10);
         update.set("name", "我是之前没有的");
         // 更新多条
         UpdateResult updateResult = mongoTemplate.upsert(
                 Query.query(Criteria.where("salary").gt(30000)),
                 update,
                 User.class
         );
         System.out.println("updateResult.getMatchedCount() = " + updateResult.getMatchedCount());
         System.out.println("updateResult.getModifiedCount() = " + updateResult.getModifiedCount());
         System.out.println("updateResult.getUpsertedId() = " + updateResult.getUpsertedId());
     }
 ​
     /**
      * 文档删除
      */
     @Test
     public void testRemoveDocument() {
         DeleteResult deleteResult = mongoTemplate.remove(Query.query(Criteria.where("id").is(9)), User.class);
         System.out.println("deleteResult.getDeletedCount() = " + deleteResult.getDeletedCount());
     }
 }

总结

以上就是SpringBoot整合MongoDB的相关知识，希望对你有所帮助。
积跬步以至千里，积怠惰以至深渊。时代在这跟着你一起努力哦！

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
MongoDB Spring Boot
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入