Springboot 2.X 集成 MongoDB 使用 MongoTemplate 实现基本增删改查

​
​

1 摘要

MongoDB 作为应用广泛的文档数据库，Spring 对其提供了丰富的操作支持。主要操作 MongoDB 的类有 MongoRepository 以及 MongoTemplate。关于这两者的关系， MongoRepository 提供了 JPA 风格的操作接口，底层是通过的 MongoTemplate 进行实现，而 MongoTemplate 提供了更加丰富的操作接口。至于要使用哪个类来操作 MongoDB，作者个人认为如果只有简单的增删改查，并且习惯了 JPA 的风格，则可以使用 MongoRepository ，如果有对数据进行复杂的操作，如批量操作、分组统计等，则推荐使用 MongoTemplate。本文将介绍使用 MongoTemplate 实现基本的增删改查(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: root
      password: root666
      database: springboot
      host: 127.0.0.1
      port: 27017

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

​

4 核心代码

4.1 实体类

基础实体类

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

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

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.mongodb.core.mapping.Field;

import java.io.Serializable;

/**
 * @Description: 基础实体类
 * @Author: junqiang.lu
 * @Date: 2021/9/24
 */
@Data
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -3003658740476069858L;

    /**
     * id,主键
     */
    @Id
    @ApiModelProperty(value = "id,主键", name = "id")
    private String id;
    /**
     * 创建时间
     */
    @Field
    @CreatedDate
    @ApiModelProperty(value = "创建时间", name = "createTime")
    private Long createTime;
    /**
     * 修改时间
     */
    @Field
    @LastModifiedDate
    @ApiModelProperty(value = "修改时间", name = "updateTime")
    private Long updateTime;
}

@Id : 标注当前字段为 id 主键

@Field: 标注当前字段为数据库字段

@CreatedDate: 创建时间注解，当插入数据是触发，支持的数据类型有 Long/Date

@LastModifiedDate: 最后更新时间注解，当更新数据时触发，首次插入则时间同 @CreateDate，支持的数据类型有 Long/Date

若要让 @CreateDate，@LastModifiedDate 注解生效，需要在 SpringBoot 启动类上添加 @EnableMongoAuditing 注解

博客实体类

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

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

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

/**
 * @Description: 博客信息
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Data
@ToString(callSuper = true)
@Document(value = "blog")
@ApiModel(value = "博客信息", description = "博客信息")
public class BlogEntity extends BaseEntity {

    private static final long serialVersionUID = -2124422309475024490L;

    /**
     * 标题
     */
    @Field
    @ApiModelProperty(value = "标题", name = "title")
    private String title;
    /**
     * 作者
     */
    @Field
    @ApiModelProperty(value = "作者", name = "author")
    private String author;
    /**
     * 内容
     */
    @Field
    @ApiModelProperty(value = "内容", name = "content")
    private String content;
    /**
     * 阅读数量
     */
    @Field
    @ApiModelProperty(value = "阅读数量", name = "countRead")
    private Integer countRead;
    /**
     * 点赞数量
     */
    @Field
    @ApiModelProperty(value = "点赞数量", name = "countLike")
    private Integer countLike;
    /**
     * 客户端时间戳(精确到秒)
     */
    @Field
    @ApiModelProperty(value = "客户端时间戳(精确到秒)", name = "clientTimestamp")
    private Integer clientTimestamp;



}

@Document(value = "blog") : Mongo 文档数据库表注解，value 属性为Mongo数据库表名(集合名称)。

4.2 MongoTemplate 核心操作示例-业务实现类

业务接口

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

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

import com.ljq.demo.springboot.mongodb.common.api.ApiResult;
import com.ljq.demo.springboot.mongodb.model.param.*;

/**
 * @Description: 博客业务接口
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
public interface BlogService {

    /**
     * 新增单条博客
     *
     * @param addParam
     * @return
     */
    ApiResult add(BlogAddParam addParam);

    /**
     * 查询单条博客
     *
     * @param queryOneParam
     * @return
     */
    ApiResult queryOne(BlogQueryOneParam queryOneParam);

    /**
     * 分页查询博客
     *
     * @param queryPageParam
     * @return
     */
    ApiResult queryPage(BlogQueryPageParam queryPageParam);

    /**
     * 更新单条博客
     *
     * @param updateParam
     * @return
     */
    ApiResult update(BlogUpdateParam updateParam);

    /**
     * 删除单条博客
     *
     * @param deleteOneParam
     * @return
     */
    ApiResult deleteOne(BlogDeleteOneParam deleteOneParam);

    /**
     * 批量删除博客
     *
     * @param deleteBatchParam
     * @return
     */
    ApiResult deleteBatch(BlogDeleteBatchParam deleteBatchParam);


}

业务实现类

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

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

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.util.StrUtil;
import com.ljq.demo.springboot.mongodb.common.api.ApiResult;
import com.ljq.demo.springboot.mongodb.common.api.ResponseCode;
import com.ljq.demo.springboot.mongodb.model.entity.BlogEntity;
import com.ljq.demo.springboot.mongodb.model.param.*;
import com.ljq.demo.springboot.mongodb.service.BlogService;
import com.mongodb.client.result.DeleteResult;
import lombok.extern.slf4j.Slf4j;
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.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.support.PageableExecutionUtils;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Objects;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @Description: 博客业务实现类
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Slf4j
@Service("blogService")
public class BlogServiceImpl implements BlogService {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 新增单条博客
     *
     * @param addParam
     * @return
     */
    @Override
    public ApiResult add(BlogAddParam addParam) {
        BlogEntity blogEntity = new BlogEntity();
        BeanUtil.copyProperties(addParam, blogEntity, CopyOptions.create().ignoreError().ignoreNullValue());
        mongoTemplate.save(blogEntity);
        return ApiResult.success(blogEntity);
    }

    /**
     * 查询单条博客
     *
     * @param queryOneParam
     * @return
     */
    @Override
    public ApiResult queryOne(BlogQueryOneParam queryOneParam) {
        Query query = Query.query(Criteria.where("id").is(queryOneParam.getId()));
        return ApiResult.success(mongoTemplate.findOne(query, BlogEntity.class));
    }

    /**
     * 分页查询博客
     *
     * @param queryPageParam
     * @return
     */
    @Override
    public ApiResult queryPage(BlogQueryPageParam queryPageParam) {
        // 查询条件
        Criteria criteria = new Criteria();
        if (StrUtil.isNotBlank(queryPageParam.getId())) {
            criteria = criteria.and("id").is(queryPageParam.getId());
        }
        if (StrUtil.isNotBlank(queryPageParam.getTitle())) {
            Pattern titlePattern = Pattern.compile("^.*" + queryPageParam.getTitle() + ".*$",
                    Pattern.CASE_INSENSITIVE);
            criteria.and("title").regex(titlePattern);
        }
        if (StrUtil.isNotBlank(queryPageParam.getAuthor())) {
            criteria.and("author").is(queryPageParam.getAuthor());
        }
        if (StrUtil.isNotBlank(queryPageParam.getContent())) {
            Pattern contentPattern = Pattern.compile("^.*" + queryPageParam.getContent() + ".*$",
                    Pattern.CASE_INSENSITIVE);
            criteria.and("content").regex(contentPattern);
        }
        Query query = Query.query(criteria);
        // 分页查询
        long count = mongoTemplate.count(query, BlogEntity.class);
        Pageable pageParam = PageRequest.of(queryPageParam.getCurrentPage()-1, queryPageParam.getPageSize(),
                Sort.by(Sort.Direction.DESC, "updateTime"));
        List<BlogEntity> list = mongoTemplate.find(query.with(pageParam), BlogEntity.class);
        Page<BlogEntity> pageResult = PageableExecutionUtils.getPage(list, pageParam, () -> count);
        return ApiResult.success(pageResult);
    }

    /**
     * 更新单条博客
     *
     * @param updateParam
     * @return
     */
    @Override
    public ApiResult update(BlogUpdateParam updateParam) {
        BlogEntity blogEntity = mongoTemplate.findById(updateParam.getId(), BlogEntity.class);
        if (Objects.isNull(blogEntity)) {
            return ApiResult.failure(ResponseCode.BLOG_NOT_EXIST);
        }
        BeanUtil.copyProperties(updateParam, blogEntity, CopyOptions.create().ignoreError().ignoreNullValue());
        mongoTemplate.save(blogEntity);
        return ApiResult.success(blogEntity);
    }

    /**
     * 删除单条博客
     *
     * @param deleteOneParam
     * @return
     */
    @Override
    public ApiResult deleteOne(BlogDeleteOneParam deleteOneParam) {
        DeleteResult result = mongoTemplate.remove(Query.query(Criteria.where("id").is(deleteOneParam.getId())),
                BlogEntity.class);
        if (result.getDeletedCount() < 1) {
            return ApiResult.failure(ResponseCode.BLOG_NOT_EXIST);
        }
        return ApiResult.success();
    }

    /**
     * 批量删除博客
     *
     * @param deleteBatchParam
     * @return
     */
    @Override
    public ApiResult deleteBatch(BlogDeleteBatchParam deleteBatchParam) {
        List<String> idList = deleteBatchParam.getIdList().stream()
                .map(BlogDeleteOneParam::getId).collect(Collectors.toList());
        DeleteResult result = mongoTemplate.remove(Query.query(Criteria.where("id").in(idList)), BlogEntity.class);
        return ApiResult.success(result.getDeletedCount());
    }
}

对象简要说明:

org.springframework.data.mongodb.core.query.Criteria: 用于构建查询条件

org.springframework.data.mongodb.core.query.Query: 查询对象

4.3 其他操作类-请求参数

新增操作请求参数

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/BlogAddParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.hibernate.validator.constraints.Length;

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

/**
 * @Description: 新增单条博客
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Data
@ApiModel(value = "新增单条博客", description = "新增单条博客")
public class BlogAddParam implements Serializable {

    private static final long serialVersionUID = -2784787111136075605L;

    /**
     * 标题
     */
    @NotBlank(message = "博客标题不能为空")
    @Length(min = 1, max = 128,message = "博客标题需要控制在 1-128 字符以内")
    @ApiModelProperty(value = "标题", name = "title", required = true)
    private String title;
    /**
     * 作者
     */
    @NotBlank(message = "博客作者不能为空")
    @Length(min = 1, max = 64,message = "博客作者需要控制在 1-64 字符以内")
    @ApiModelProperty(value = "作者", name = "author", required = true)
    private String author;
    /**
     * 内容
     */
    @NotBlank(message = "博客内容不能为空")
    @Length(min = 1, max = 50000,message = "博客内容需要控制在 1-50000 字符以内")
    @ApiModelProperty(value = "内容", name = "content", required = true)
    private String content;
    /**
     * 客户端时间戳(精确到秒)
     */
    @NotNull(message = "客户端时间戳不能为空")
    @ApiModelProperty(value = "客户端时间戳(精确到秒)", name = "clientTimestamp", required = true)
    private Integer clientTimestamp;

}

查询单条请求参数

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/BlogQueryOneParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
import java.io.Serializable;

/**
 * @Description: 查询单条博客
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Data
@ApiModel(value = "查询单条博客", description = "查询单条博客")
public class BlogQueryOneParam implements Serializable {

    private static final long serialVersionUID = 4514138839894210912L;

    /**
     * 博客 id
     */
    @NotBlank(message = "博客 ID 不能为空")
    @Pattern(regexp = "^[0-9a-zA-Z]{1,64}$", message = "博客 ID 不合法")
    @ApiModelProperty(value = "博客 ID", name = "id", required = true)
    private String id;

}

分页查询请求参数

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/BasePageParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

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

/**
 * @Description: 分页查询基础参数
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Data
@ApiModel(value = "分页查询基础参数", description = "分页查询基础参数")
public class BasePageParam implements Serializable {

    private static final long serialVersionUID = -1676313147351509759L;

    /**
     * 当前页
     */
    @NotNull(message = "当前页不能为空")
    @Min(value = 1, message = "当前页至少为 1")
    @ApiModelProperty(value = "当前页,不能为空,至少为 1", name = "currentPage", required = true, example = "1")
    private Integer currentPage;
    /**
     * 每页显示条数
     */
    @NotNull(message = "每页显示条数不能为空")
    @Min(value = 3, message = "每页至少展示 3 条结果")
    @Max(value = 100, message = "每页最多展示 100 条结果")
    @ApiModelProperty(value = "每页显示条数,每页至少展示 3 条结果,最多为 100 条", name = "pageSize", required = true,
            example = "5")
    private Integer pageSize;


}

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/BlogQueryPageParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;

import javax.validation.constraints.Pattern;

/**
 * @Description: 分页查询博客
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Data
@ToString(callSuper = true)
@ApiModel(value = "分页查询博客", description = "分页插叙博客")
public class BlogQueryPageParam extends BasePageParam {

    private static final long serialVersionUID = 362651641919164224L;

    /**
     * 博客 id
     */
    @Pattern(regexp = "^[0-9a-zA-Z]{0,64}$", message = "博客 ID 不合法")
    @ApiModelProperty(value = "博客 ID", name = "id")
    private String id;
    /**
     * 标题
     */
    @Length(max = 128,message = "博客标题需要控制在 128 字符以内")
    @ApiModelProperty(value = "标题", name = "title")
    private String title;
    /**
     * 作者
     */
    @Length(max = 64,message = "博客作者需要控制在 64 字符以内")
    @ApiModelProperty(value = "作者", name = "author")
    private String author;
    /**
     * 内容
     */
    @Length(max = 500,message = "博客内容需要控制在 500 字符以内")
    @ApiModelProperty(value = "内容", name = "content")
    private String content;


}

更新单条请求参数

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/BlogUpdateParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.hibernate.validator.constraints.Length;

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

/**
 * @Description: 更新单条博客
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Data
@ApiModel(value = "更新单条博客", description = "更新单条博客")
public class BlogUpdateParam implements Serializable {

    private static final long serialVersionUID = 5995420506930561290L;

    /**
     * 博客 id
     */
    @NotBlank(message = "博客 ID 不能为空")
    @Pattern(regexp = "^[0-9a-zA-Z]{1,64}$", message = "博客 ID 不合法")
    @ApiModelProperty(value = "博客 ID", name = "id", required = true)
    private String id;
    /**
     * 标题
     */
    @NotBlank(message = "博客标题不能为空")
    @Length(min = 1, max = 128,message = "博客标题需要控制在 1-128 字符以内")
    @ApiModelProperty(value = "标题", name = "title", required = true)
    private String title;
    /**
     * 作者
     */
    @NotBlank(message = "博客作者不能为空")
    @Length(min = 1, max = 64,message = "博客作者需要控制在 1-64 字符以内")
    @ApiModelProperty(value = "作者", name = "author", required = true)
    private String author;
    /**
     * 内容
     */
    @NotBlank(message = "博客内容不能为空")
    @Length(min = 1, max = 50000,message = "博客内容需要控制在 1-50000 字符以内")
    @ApiModelProperty(value = "内容", name = "content", required = true)
    private String content;
    /**
     * 客户端时间戳(精确到秒)
     */
    @NotNull(message = "客户端时间戳不能为空")
    @ApiModelProperty(value = "客户端时间戳(精确到秒)", name = "clientTimestamp", required = true)
    private Integer clientTimestamp;

}

删除单条请求参数

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserDeleteParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.hibernate.validator.constraints.Length;

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

/**
 * 参数接收类
 *
 * @author junqiang.lu
 * @date 2021-01-06 20:03:33
 */
@Data
@ApiModel(value = "删除(单条)", description = "删除(单条)")
public class UserDeleteParam implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * id
     **/
    @NotBlank(message = "id 不能为空")
    @Length(max = 64, message = "id 需要控制在 64 字符以内")
    @ApiModelProperty(value = "id不能为空", name = "id")
    private String id;


}

批量删除请求参数

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/model/param/UserDeleteBatchParam.java

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;
import java.io.Serializable;

/**
 * @Description: Mongo-用户批量删除
 * @Author: junqiang.lu
 * @Date: 2021/1/20
 */
@Data
@ApiModel(value = "Mongo-用户批量删除", description = "Mongo-用户批量删除")
public class UserDeleteBatchParam implements Serializable {

    private static final long serialVersionUID = -2899668339947463921L;

    /**
     * id 数组
     */
    @NotEmpty(message = "请选择需要删除的条目")
    @Size(max = 100, message = "每次删除的条目不超过 100 条")
    @ApiModelProperty(value = "id 数组", name = "ids")
    private String[] ids;
}

4.4 其他操作类-控制层(Controller)

./demo-mongodb/src/main/java/com/ljq/demo/springboot/mongodb/controller/BlogController.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.BlogEntity;
import com.ljq.demo.springboot.mongodb.model.param.*;
import com.ljq.demo.springboot.mongodb.service.BlogService;
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.data.domain.Page;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * @Description: 博客控制层
 * @Author: junqiang.lu
 * @Date: 2021/11/13
 */
@Slf4j
@RestController
@RequestMapping(value = "/springboot/mongo/blog")
@Api(value = "博客控制层", tags = "博客控制层")
public class BlogController {

    @Autowired
    private BlogService blogService;

    /**
     * 新增单条博客
     *
     * @param addParam
     * @return
     */
    @PostMapping(value = "/add/one")
    @ApiOperation(value = "新增单条博客", notes = "新增单条博客")
    public ResponseEntity<ApiResult<BlogEntity>> add(@RequestBody @Validated BlogAddParam addParam) {
        return ResponseEntity.ok(blogService.add(addParam));
    }

    /**
     * 查询单条博客
     *
     * @param queryOneParam
     * @return
     */
    @GetMapping(value = "/query/one")
    @ApiOperation(value = "查询单条博客", notes = "查询单条博客")
    public ResponseEntity<ApiResult<BlogEntity>> queryOne(@Validated BlogQueryOneParam queryOneParam) {
        return ResponseEntity.ok(blogService.queryOne(queryOneParam));
    }

    /**
     * 分页查询博客
     *
     * @param queryPageParam
     * @return
     */
    @GetMapping(value = "/query/page")
    @ApiOperation(value = "分页查询博客", notes = "分页查询博客")
    public ResponseEntity<ApiResult<Page<BlogEntity>>> queryPage(@Validated BlogQueryPageParam queryPageParam) {
        return ResponseEntity.ok(blogService.queryPage(queryPageParam));
    }

    /**
     * 更新单条博客
     *
     * @param updateParam
     * @return
     */
    @PutMapping(value = "/update/one")
    @ApiOperation(value = "更新单条博客", notes = "更新单条博客")
    public ResponseEntity<ApiResult<BlogEntity>> update(@RequestBody @Validated BlogUpdateParam updateParam) {
        return ResponseEntity.ok(blogService.update(updateParam));
    }

    /**
     * 删除单条博客
     *
     * @param deleteOneParam
     * @return
     */
    @DeleteMapping(value = "/delete/one")
    @ApiOperation(value = "删除单条博客", notes = "删除单条博客")
    public ResponseEntity<ApiResult<Void>> delete(@RequestBody @Validated BlogDeleteOneParam deleteOneParam) {
        return ResponseEntity.ok(blogService.deleteOne(deleteOneParam));
    }

    /**
     * 批量删除博客
     *
     * @param deleteBatchParam
     * @return
     */
    @DeleteMapping(value = "/delete/batch")
    @ApiOperation(value = "批量删除博客", notes = "批量删除博客")
    public ResponseEntity<ApiResult<Void>> deleteBatch(@RequestBody @Validated BlogDeleteBatchParam deleteBatchParam) {
        return ResponseEntity.ok(blogService.deleteBatch(deleteBatchParam));
    }

}

5 推荐参考资料

Spring Mongo 官方文档

spring mongodb 模糊查询

Mongodb系列- spring-data-mongodb使用MongoTemplate实现分页查询

SpringBoot之MongoTemplate的查询可以怎么耍

​

6 Github 源码

Gtihub 源码地址 : https://github.com/Flying9001/springBootDemo

个人公众号:404Code,分享半个互联网人的技术与思考，感兴趣的可以关注.