SpringBoot整合MongoDB

SpringBoot整合MongoDB

背景

• 大数据领域的MongoDB在实际开发中有很多应用，基于文档的存储结构和关系型数据库有很大的区别，下面来通过SpringBoot整合MongoDB来理解一下这个数据库
• 注：MongoDB中数据表叫集合Collection，一条记录叫文档Document
• 以下为SpringBoot项目配置

SpringBoot整合MongoDB

POM

• <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>2.7.2</version>
          <relativePath/> <!-- lookup parent from repository -->
      </parent>
      <groupId>com.example</groupId>
      <artifactId>mongodb</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <name>mongodb</name>
      <description>mongodb</description>
      <properties>
          <java.version>1.8</java.version>
      </properties>
      <dependencies>
          <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.springframework.boot</groupId>
              <artifactId>spring-boot-devtools</artifactId>
              <scope>runtime</scope>
              <optional>true</optional>
          </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>
      </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>
  

YML

• spring:
    data:
      mongodb:
        host: 192.168.0.1
        port: 27017
        username: root
        password: root
        database: test
        authenticationDatabase: test
  
  #spring:
  #  data:
  #    mongodb:
  #      uri: mongodb://192.168.61.4:27017/test
  
  server:
  	port: 80
  

MongoDB实体类

• @Document(“t_his_curve_highway”) 表示这条记录Document插入MongoDB中的t_his_curve_highway的Collection中

• @Indexed 表示该字段为索引

• @Field(“highway_id”) 表示该字段对应到MongoDB中的Collection中字段名为highway_id

• import com.baomidou.mybatisplus.annotation.TableField;
  import lombok.*;
  import org.springframework.data.annotation.Transient;
  import org.springframework.data.mongodb.core.index.Indexed;
  import org.springframework.data.mongodb.core.mapping.Document;
  import org.springframework.data.mongodb.core.mapping.Field;
  
  import java.io.Serializable;
  
  @Data
  @Builder(toBuilder = true)
  @NoArgsConstructor
  @AllArgsConstructor
  @EqualsAndHashCode(callSuper = false)
  @Document("t_his_curve_highway")
  public class StaCharHisCurveHighwayDto implements Serializable {
  
      /**
       * highwayId
       */
      @Indexed
      @Field("highway_id")
      private String highwayId;
  
      /**
       * recDate
       */
      @Field("rec_date")
      private String recDate;
  
      /**
       * curveCode
       */
      @Field("curve_code")
      private String curveCode;
  
      /**
       * curveData
       */
      @Field("curve_data")
      private String curveData;
  
      /**
       * recId
       */
      @TableField("recId")
      private String recId;
  
      /**
       * day
       */
      @Transient
      private Integer day;
  
  }
  

MongoDB接口

• import com.xxx.job.dto.HighwayDto;
  import java.util.List;
  
  public interface MongoDBRepository {
  
      void saveHighwayData(List<HighwayDto> highwayDtoList);
      
  }
  

MongoDB接口实现类

• 使用MongoTemplate实现MongoDB批量插入数据功能

• import com.xxx.job.dto.HighwayDto;
  import lombok.extern.slf4j.Slf4j;
  import org.bson.Document;
  import org.springframework.data.mongodb.core.BulkOperations;
  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.data.util.Pair;
  import org.springframework.stereotype.Component;
  
  import javax.annotation.Resource;
  import java.util.ArrayList;
  import java.util.List;
  
  @Component
  @Slf4j
  public class MongoDBRepositoryImpl implements MongoDBRepository {
  
      //注入MongoTemplate
      @Resource
      private MongoTemplate mongoTemplate;
  
      /**
       * 添加数据
       *
       * @param staCharHisCurveHighwayDtoList
       */
      @Override
      public void saveStaCharHisCurveHighwayData(List<HighwayDto> highwayDtoList) {
  	    
  	    log.info("Highway正在写入mongodb数据库，数量 {} ", highwayDtoList.size());
  	
  	    List<Pair<Query, Update>> updateList = new ArrayList<>(highwayDtoList.size());
  	
  		//bulkOps批量操作
  	    BulkOperations operations = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, HighwayDto.class);
  	    
  	    //处理List
  	    highwayDtoList.forEach(data -> {
  	    	//匹配id的数据
  	        Query query = new Query(new Criteria("id").is(data.getId()));
  	        Update update;
  	        Document doc = new Document();
  	        //把数据写入doc
  	        mongoTemplate.getConverter().write(data, doc);
  	        //用doc生成update对象
  	        update = Update.fromDocument(new Document("$set", doc));
  	        Pair<Query, Update> updatePair = Pair.of(query, update);
  	        updateList.add(updatePair);
  	    });
  	
  		//upsert = update + insert
  	    operations.upsert(updateList);
  		
  		//执行
  	    operations.execute();
  	
  	}
  	
  }
  

效果

• MongoDB数据库表Collection
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oaZbLtl6-1690847629870)(C:\Users\quyanliang\AppData\Roaming\Typora\typora-user-images\1690847485365.png)]

MongoTemplate增删改查测试用例

实体

• package com.example.mongodb.entity;
  
  import lombok.Data;
  import org.springframework.data.annotation.Id;
  import org.springframework.data.mongodb.core.mapping.Document;
  import org.springframework.data.mongodb.core.mapping.Field;
  
  import java.io.Serializable;
  
  @Data
  @Document("User")
  public class User implements Serializable {
  
      @Id
      private String id;
      private String name;
      private Integer age;
      private String email;
      @Field("create_date")
      private String createDate;
  
  }
  

测试用例

• 在SpringBoot中Test文件夹下编写测试用例使用Mongo Template实现数据的增删改查

• package com.example.mongodb.test;
  
  import com.example.mongodb.entity.User;
  import com.mongodb.client.result.DeleteResult;
  import com.mongodb.client.result.UpdateResult;
  import org.junit.jupiter.api.Test;
  import org.springframework.boot.test.context.SpringBootTest;
  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 javax.annotation.Resource;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Pattern;
  
  @SpringBootTest
  class MongoTemplateTest {
  
      @Resource
      private MongoTemplate mongoTemplate;
  
      //添加
      @Test
      public void createUser() {
          User user = new User();
          user.setAge(23);
          user.setName("test2");
          user.setEmail("4922001@qq.com");
          user.setCreateDate(String.valueOf(new Date()));
          User user1 = mongoTemplate.insert(user);
          System.out.println(user1);
      }
  
      //查询所有
      @Test
      public void findUser() {
          List<User> userList = mongoTemplate.findAll(User.class);
          System.out.println(userList);
      }
  
      //根据id查询
      @Test
      public void getById() {
          User user =
                  mongoTemplate.findById("60534ac7548d761b193cf2d7", User.class);
          System.out.println(user);
      }
  
      //条件查询
      @Test
      public void findUserList() {
          Query query = new Query(Criteria
                  .where("name").is("test")
                  .and("age").is(20));
          List<User> userList = mongoTemplate.find(query, User.class);
          System.out.println(userList);
      }
  
      //模糊查询
      @Test
      public void findUsersLikeName() {
          String name = "est";
          String regex = String.format("%s%s%s", "^.*", name, ".*$");
          Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
          Query query = new Query(Criteria.where("name").regex(pattern));
          List<User> userList = mongoTemplate.find(query, User.class);
          System.out.println(userList);
      }
  
      //分页查询
      @Test
      public void findUsersPage() {
          String name = "est";
          int pageNo = 1;
          int pageSize = 10;
  
          Query query = new Query();
          String regex = String.format("%s%s%s", "^.*", name, ".*$");
          Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
          query.addCriteria(Criteria.where("name").regex(pattern));
          int totalCount = (int) mongoTemplate.count(query, User.class);
          List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);
  
          Map<String, Object> pageMap = new HashMap<>();
          pageMap.put("list", userList);
          pageMap.put("totalCount",totalCount);
          System.out.println(pageMap);
      }
  
      //修改
      @Test
      public void updateUser() {
          User user = mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
          user.setName("test_1");
          user.setAge(25);
          user.setEmail("493220990@qq.com");
          Query query = new Query(Criteria.where("_id").is(user.getId()));
          Update update = new Update();
          update.set("name", user.getName());
          update.set("age", user.getAge());
          update.set("email", user.getEmail());
          UpdateResult result = mongoTemplate.upsert(query, update, User.class);
          long count = result.getModifiedCount();
          System.out.println(count);
      }
  
      //删除操作
      @Test
      public void delete() {
          Query query =
                  new Query(Criteria.where("_id").is("5ffbfa2ac290f356edf9b5aa"));
          DeleteResult result = mongoTemplate.remove(query, User.class);
          long count = result.getDeletedCount();
          System.out.println(count);
      }
  }
  

效果

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FoBT9w65-1690847629870)(C:\Users\quyanliang\AppData\Roaming\Typora\typora-user-images\1690847557331.png)]

MongoRepository增删改查测试用例

• 使用MongoRepository实现MongoDB的增删改查

MongoRepository

• 实现MongoRepository接口

• package com.example.mongodb.repository;
  
  import com.example.mongodb.entity.User;
  import org.springframework.data.mongodb.repository.MongoRepository;
  import org.springframework.stereotype.Repository;
  
  @Repository
  public interface UserRepository extends MongoRepository<User, String> {
  
  }
  

测试用例

• 通过MongoRepository实现MongoDB的Collection的增删改查

• package com.example.mongodb.test;
  
  import com.example.mongodb.entity.User;
  import com.example.mongodb.repository.UserRepository;
  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.*;
  
  import java.util.List;
  
  @SpringBootTest
  class MongoRepositoryTest {
  
      @Autowired
      private UserRepository userRepository;
  
      //添加
      @Test
      public void createUser() {
          User user = new User();
          user.setAge(12);
          user.setName("李四");
          user.setEmail("323332200@qq.com");
          User userRes = userRepository.save(user);
          System.out.println(userRes);
      }
  
      //查询所有
      @Test
      public void findUser() {
          List<User> userList = userRepository.findAll();
          System.out.println(userList);
      }
  
      //id查询
      @Test
      public void getById() {
          User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
          System.out.println(user);
      }
  
      //条件查询
      @Test
      public void findUserList() {
          User user = new User();
          user.setName("张三");
          user.setAge(20);
          Example<User> userExample = Example.of(user);
          List<User> userList = userRepository.findAll(userExample);
          System.out.println(userList);
      }
  
      //模糊查询
      @Test
      public void findUsersLikeName() {
          //创建匹配器，即如何使用查询条件
          ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                  .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                  .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
          User user = new User();
          user.setName("三");
          Example<User> userExample = Example.of(user, matcher);
          List<User> userList = userRepository.findAll(userExample);
          System.out.println(userList);
      }
  
      //分页查询
      @Test
      public void findUsersPage() {
          Sort sort = Sort.by(Sort.Direction.DESC, "age");
          //0为第一页
          Pageable pageable = PageRequest.of(0, 10, sort);
          //创建匹配器，即如何使用查询条件
          ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                  .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                  .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
          User user = new User();
          user.setName("三");
          Example<User> userExample = Example.of(user, matcher);
          //创建实例
          Example<User> example = Example.of(user, matcher);
          Page<User> pages = userRepository.findAll(example, pageable);
          System.out.println(pages);
      }
  
      //修改
      @Test
      public void updateUser() {
          User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
          user.setName("张三_1");
          user.setAge(25);
          user.setEmail("883220990@qq.com");
          User save = userRepository.save(user);
          System.out.println(save);
      }
  
      //删除
      @Test
      public void delete() {
          userRepository.deleteById("5ffbfe8197f24a07007bd6ce");
      }
  }