Skip to content

63.spring_boot_2.4_mongodb.md

Latest commit

 

History

History
548 lines (438 loc) · 14.6 KB

63.spring_boot_2.4_mongodb.md

File metadata and controls

548 lines (438 loc) · 14.6 KB

Spring Boot 2.4 集成 MongoDB 实现基本 CRUD

​
​

1 摘要

MongoDB 作为一种基于分布式文档存储的数据库，所存数据即为一个文件。数据结构为键值对的方式(key-value)。本文将介绍基于 Spring Boot 2.4 集成 MongDB，实现基本的增删改查(CRUD)。

MongoDB 官方文档: https://docs.atlas.mongodb.com/getting-started

​

2 核心 Maven 依赖

./demo-mongodb/pom.xml

        <!-- mongodb -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

Spring Boot 提供了官方的集成依赖，版本号与 SpringBoot 版本一致，本示例中版本为 2.4.1

​

3 配置信息

./demo-mongodb/src/main/resources/application.yml

## config

server:
  port: 8650

## spring config
spring:
  data:
    mongodb:
      authentication-database: admin
      username: rout
      password: routSa213
      database: admin
      host: 172.16.140.10
      port: 27017

## log
logging:
  level:
    org.springframework.data.mongodb.core.MongoTemplate: debug
    org.springframework.data.couchbase.repository.query : debug

如需要打印MongoDB执行的SQL日志，则配置日志信息。如许对日志进行过滤，可在 logbak 的配置文件中进行配置。

./demo-mongodb/src/main/resources/logback.xml

    <logger name="org.mongodb.driver.protocol.command" level="info" />

如果不过滤，则控制台会频繁输出 MongoDB 的查询扫描日志。可根据情况确定是否开启日志。

​

4 核心Java代码

4.1 实体类

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/entity/UserEntity.java

package com.ljq.demo.springboot.mongodb.model.entity;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 * @Description: 用户信息
 * @Author: junqiang.lu
 * @Date: 2021/1/6
 */
@Data
@Document(value = "user")
@ApiModel(value = "用户信息", description = "用户信息")
public class UserEntity {

    /**
     * id
     */
    @Id
    @ApiModelProperty(value = "id", name = "id")
    private String id;
    /**
     * 姓名
     */
    @ApiModelProperty(value = "姓名", name = "name")
    private String name;
    /**
     * 年龄
     */
    @ApiModelProperty(value = "年龄", name = "age")
    private Integer age;
    /**
     * 简介
     */
    @ApiModelProperty(value = "简介", name = "introduction")
    private String introduction;
}

@Document 注解表明该对象为 MongoDB 的文档，其 value 属性用于定义文档的名称

@Id 注解表明该字段为主键，MongoDB在保存数据时会自动生成一条名为 _id 的值作为该条数据的唯一编码，其Java数据类型为 org.bson.types.ObjectId ，使用 @Id 注解可实现数据的自动转换

4.2 数据持久层

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/repository/UserRepository.java

package com.ljq.demo.springboot.mongodb.repository;

import com.ljq.demo.springboot.mongodb.model.entity.UserEntity;
import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

/**
 * @Description: 用户数据持久层
 * @Author: junqiang.lu
 * @Date: 2021/1/6
 */
public interface UserRepository extends MongoRepository<UserEntity, String> {

    /**
     * 根据年龄查询
     *
     * @param age
     * @return
     */
    List<UserEntity> findByAge(Integer age);


}

MopngoDB 的数据持久成操作和其他数据库类型的数据持久层操作代码风格一致，都是 JPA 的实现。这一点是和 Mybatis 有一定的区别。

4.3 业务层

业务接口

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/service/UserService.java

package com.ljq.demo.springboot.mongodb.service;

import com.ljq.demo.springboot.mongodb.model.entity.UserEntity;
import com.ljq.demo.springboot.mongodb.model.param.*;
import org.springframework.data.domain.Page;

/**
 * 业务层接口
 * 
 * @author junqiang.lu
 * @date 2021-01-06 20:03:33
 */
public interface UserService {

	/**
     * 保存(单条)
     *
     * @param userSaveParam
     * @return
     */
	UserEntity save(UserSaveParam userSaveParam);

	/**
     * 查询详情(单条)
     *
     * @param userInfoParam
     * @return
     */
	UserEntity info(UserInfoParam userInfoParam);

	/**
     * 查询列表
     *
     * @param userListParam
     * @return
     */
	Page<UserEntity> list(UserListParam userListParam);

	/**
     * 更新(单条)
     *
     * @param userUpdateParam
     * @return
     */
	UserEntity update(UserUpdateParam userUpdateParam);

	/**
     * 删除(单条)
     *
     * @param userDeleteParam
     * @return
     */
	void delete(UserDeleteParam userDeleteParam);

	/**
	 * 批量删除
	 *
	 * @param deleteBatchParam
	 */
	void deleteBatch(UserDeleteBatchParam deleteBatchParam);


}

业务层实现类

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/service/impl/UserServiceImpl.java

package com.ljq.demo.springboot.mongodb.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import com.ljq.demo.springboot.mongodb.model.entity.UserEntity;
import com.ljq.demo.springboot.mongodb.model.param.*;
import com.ljq.demo.springboot.mongodb.repository.UserRepository;
import com.ljq.demo.springboot.mongodb.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

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

/**
 * @Description: 用户业务层实现类
 * @Author: junqiang.lu
 * @Date: 2021/1/7
 */
@Service(value = "userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    /**
     * 保存(单条)
     *
     * @param userSaveParam
     * @return
     */
    @Override
    public UserEntity save(UserSaveParam userSaveParam) {
        UserEntity userParam = new UserEntity();
        BeanUtil.copyProperties(userSaveParam,userParam, CopyOptions.create().ignoreError().ignoreNullValue());
        userParam = userRepository.save(userParam);
        return userParam;
    }

    /**
     * 查询详情(单条)
     *
     * @param userInfoParam
     * @return
     */
    @Override
    public UserEntity info(UserInfoParam userInfoParam) {
        Optional<UserEntity> userDBOpt = userRepository.findById(userInfoParam.getId());
        return userDBOpt.get();
    }

    /**
     * 查询列表
     *
     * @param userListParam
     * @return
     */
    @Override
    public Page<UserEntity> list(UserListParam userListParam) {
        Pageable pageable = PageRequest.of(userListParam.getCurrentPage() - 1, userListParam.getPageSize());
        Page<UserEntity> userDBPage = userRepository.findAll(pageable);
        return userDBPage;
    }

    /**
     * 更新(单条)
     *
     * @param userUpdateParam
     * @return
     */
    @Override
    public UserEntity update(UserUpdateParam userUpdateParam) {
        UserEntity userParam = new UserEntity();
        BeanUtil.copyProperties(userUpdateParam, userParam, CopyOptions.create().ignoreNullValue());
        userRepository.save(userParam);
        return userParam;
    }

    /**
     * 删除(单条)
     *
     * @param userDeleteParam
     * @return
     */
    @Override
    public void delete(UserDeleteParam userDeleteParam) {
        userRepository.deleteById(userDeleteParam.getId());
    }

    @Override
    public void deleteBatch(UserDeleteBatchParam deleteBatchParam) {
        List<UserEntity> list = new ArrayList<>();
        UserEntity userEntity;
        for (int i = 0; i < deleteBatchParam.getIds().length; i++) {
            userEntity = new UserEntity();
            userEntity.setId(deleteBatchParam.getIds()[i]);
            list.add(userEntity);
        }
        userRepository.deleteAll(list);
    }
}

Spring Boot 已经将对MongoDB数据库的操作封装好了，直接按照 JPA 的操作方式来对数据进行增删改查即可。

4.4 控制层

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/controller/UserController.java

package com.ljq.demo.springboot.mongodb.controller;

import com.ljq.demo.springboot.mongodb.common.api.ApiResult;
import com.ljq.demo.springboot.mongodb.model.entity.UserEntity;
import com.ljq.demo.springboot.mongodb.model.param.*;
import com.ljq.demo.springboot.mongodb.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * 
 * 
 * @author junqiang.lu
 * @date 2021-01-06 20:03:33
 */
@Slf4j
@RestController
@RequestMapping(value = "/springboot/mongo/user")
@Api(value = "Mongo-用户控制层", tags = "Mongo-用户控制层")
public class UserController {

	@Autowired
	private UserService userService;

    /**
     * 保存(单条)
     *
     * @param userSaveParam
     * @return
     */
    @PostMapping(value = "/add", produces = {MediaType.APPLICATION_JSON_VALUE})
    @ApiOperation(value = "Mongo-用户保存(单条)",  notes = "用户保存(单条)")
    public ResponseEntity<ApiResult> save(@Validated @RequestBody UserSaveParam userSaveParam) {
        return ResponseEntity.ok(ApiResult.success(userService.save(userSaveParam)));
    }

    /**
     * 查询详情(单条)
     *
     * @param userInfoParam
     * @return
     */
    @GetMapping(value = "/info", produces = {MediaType.APPLICATION_JSON_VALUE})
    @ApiOperation(value = "Mongo-用户查询详情(单条)",  notes = "用户查询详情(单条)")
    public ResponseEntity<ApiResult> info(@Validated UserInfoParam userInfoParam) {
        return ResponseEntity.ok(ApiResult.success(userService.info(userInfoParam)));
    }

    /**
     * 查询列表
     *
     * @param userListParam
     * @return
     */
    @GetMapping(value = "/list", produces = {MediaType.APPLICATION_JSON_VALUE})
    @ApiOperation(value = "Mongo-用户查询列表",  notes = "用户查询列表")
    public ResponseEntity<ApiResult> list(@Validated UserListParam userListParam) {
        return ResponseEntity.ok(ApiResult.success(userService.list(userListParam)));
    }

    /**
     * 修改(单条)
     *
     * @param userUpdateParam
     * @return
     */
    @PutMapping(value = "/update", produces = {MediaType.APPLICATION_JSON_VALUE})
    @ApiOperation(value = "Mongo-用户修改(单条)",  notes = "用户修改(单条)")
    public ResponseEntity<ApiResult<UserEntity>> update(@Validated @RequestBody UserUpdateParam userUpdateParam) {
        return ResponseEntity.ok(ApiResult.success(userService.update(userUpdateParam)));
    }

    /**
     * 删除(单条)
     *
     * @param userDeleteParam
     * @return
     */
    @DeleteMapping(value = "/delete", produces = {MediaType.APPLICATION_JSON_VALUE})
    @ApiOperation(value = "Mongo-用户删除(单条)",  notes = "用户删除(单条)")
    public ResponseEntity<ApiResult<Void>> delete(@Validated @RequestBody UserDeleteParam userDeleteParam) {
        userService.delete(userDeleteParam);
        return ResponseEntity.ok(ApiResult.success());
    }

    /**
     * Mongo-用户批量删除
     *
     * @param deleteBatchParam
     * @return
     */
    @DeleteMapping(value = "/delete/batch", produces = {MediaType.APPLICATION_JSON_VALUE})
    @ApiOperation(value = "Mongo-用户批量删除",  notes = "Mongo-用户批量删除")
    public ResponseEntity<ApiResult<Void>> deleteBatch(@Validated @RequestBody UserDeleteBatchParam deleteBatchParam) {
        userService.deleteBatch(deleteBatchParam);
        return ResponseEntity.ok(ApiResult.success());
    }


}

4.5 SpringBoot 启动类

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/DemoMongodbApplication.java

package com.ljq.demo.springboot.mongodb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * @author junqiang.lu
 */
@EnableSwagger2
@SpringBootApplication
public class DemoMongodbApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoMongodbApplication.class, args);
    }

}

4.6 其他相关代码

请求参数封装类

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserSaveParam.java
./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserInfoParam.java
./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserListParam.java
./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserUpdateParam.java
./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserDeleteParam.java
./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserDeleteBatchParam.java

返回结果封装

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/common/api/ApiResult.java
./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/common/api/ResponseCode.java

​

5 推荐参考资料

Spring Boot MongoDB CRUD Example

Introduction to Spring Data MongoDB

Spring 官方: Accessing Data with MongoDB

6 本次提交记录

commit 79193910e046656407951ee1878a19a9cd2605bb (HEAD -> dev, origin/master, origin/dev, origin/HEAD, master)
Author: ljq <flying9001@gmail.com>
Date:   Wed Jan 20 19:42:55 2021 +0800

    代码-添加 Spring Boot 2.4 集成 MongoDB,实现基本CRUD

版本回退命令

git reset --soft 79193910e046656407951ee1878a19a9cd2605bb