SpringBoot整合MongoDB进行CRUD

涛哥

2023-4-22

SpringBoot

本文最后更新于2023.06.23-07:45，某些文章具有时效性，若有错误或已失效，请在下方留言或联系涛哥。

什么是MongoDB ?

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。

在高负载的情况下，添加更多的节点，可以保证服务器性能。

MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

主要特点

MongoDB 是一个面向文档存储的数据库，操作起来比较简单和容易。
你可以在MongoDB记录中设置任何属性的索引 (如：FirstName="Sameer",Address="8 Gandhi Road")来实现更快的排序。
你可以通过本地或者网络创建数据镜像，这使得MongoDB有更强的扩展性。
如果负载的增加（需要更多的存储空间和更强的处理能力），它可以分布在计算机网络中的其他节点上这就是所谓的分片。
Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。
MongoDb 使用update()命令可以实现替换完成的文档（数据）或者一些指定的数据字段。
Mongodb中的Map/reduce主要是用来对数据进行批量处理和聚合操作。
Map和Reduce。Map函数调用emit(key,value)遍历集合中所有的记录，将key与value传给Reduce函数进行处理。
Map函数和Reduce函数是使用Javascript编写的，并可以通过db.runCommand或mapreduce命令来执行MapReduce操作。
GridFS是MongoDB中的一个内置功能，可以用于存放大量小文件。
MongoDB允许在服务端执行脚本，可以用Javascript编写某个函数，直接在服务端执行，也可以把函数的定义存储在服务端，下次直接调用即可。
MongoDB支持各种编程语言:RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。
MongoDB安装简单。

安装MongoDB

下载地址

配置

初始化创建测试数据库

use test;
db.createCollection(''user");
db.user.save([{
    username: 'aaa',
    password: '123'
}, {
    username: 'bbb',
    password: '123'
},{
    username: 'ccc',
    password: '123'
}, {
    username: 'ddd',
    password: '123'
},{
    username: 'eee',
    password: '123'
}, {
    username: 'fff',
    password: '123'
}, {
    username: 'ggg',
    password: '123'
}]);

创建一个SpringBoot项目集成MongoDB

CRUD方式：

MongoTemplate
MongoRepository

这里使用第一种

pom.xml

         <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>
       <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.6</version>
        </dependency>

通用结果返回类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Program: SpringBoot_MongoDB
 * @ClassName Result
 * @Author: liutao
 * @Description: 通用结果
 * @Create: 2023-03-14 03:37
 * @Version 1.0
 **/

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> {
    private String code;
    private String msg;
    private Object data;

    public static<T> Result<T> success() {
        return new Result<T>(Constants.CODE_200, "", null);
    }

    public static<T> Result<T> success(Object data) {
        return new Result<T>(Constants.CODE_200, "成功", data);
    }

    public static<T> Result<T> waring(String msg, Object data) {
        return new Result<T>(Constants.CODE_550, msg, data);
    }

    public static<T> Result<T> error(String code, String msg) {
        return new Result<T>(code, msg, null);
    }

    public static<T> Result<T> error() {
        return new Result<T>(Constants.CODE_500, "系统错误", null);
    }
}

状态码

/**
 * @Program: SpringBoot_MongoDB
 * @ClassName Constants
 * @Author: liutao
 * @Description:
 * @Create: 2023-03-14 03:40
 * @Version 1.0
 **/
public interface Constants {
    String CODE_200 = "200";
    String CODE_500 = "500";
    String CODE_401 = "401";
    String CODE_403 = "403";
    //系统错误
    String CODE_400 = "400";
    String CODE_404 = "404";
    //其他业务异常
    String CODE_600 = "600";
//    文件上传重复
    String CODE_550 = "550";
    String DICT_TYPE_ICON = "icon";

}

实体类User

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

/**
 * @Program: SpringBoot_MongoDB
 * @ClassName User
 * @Author: liutao
 * @Description:
 * @Create: 2023-04-22 16:56
 * @Version 1.0
 **/

@Data
@Document("user")
@ApiModel("user")
public class User {
    @Id
    private String id;
    private String username;
    private String password;
}

service业务层

import com.example.mongodb.entity.User;

import java.util.HashMap;
import java.util.List;

/**
 * @Program: SpringBoot_MongoDB
 * @ClassName UserService
 * @Author: liutao
 * @Description:
 * @Create: 2023-04-22 17:35
 * @Version 1.0
 **/

public interface UserService {
    User insert(User user);

    User update(User user);

    List<User> findAll();

    User findById(String id);

    Boolean deleteById(String id);

    Boolean deleteByIds(List<String> ids);

    HashMap<String, Object> findPage(Integer pageNum, Integer pageSize);
}

service实现类

import com.example.mongodb.common.Constants;
import com.example.mongodb.entity.User;
import com.example.mongodb.mapper.UserRepository;
import com.example.mongodb.service.UserService;
import com.mongodb.client.result.UpdateResult;
import org.springframework.beans.factory.annotation.Autowired;
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.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.HashMap;
import java.util.List;

/**
 * @Program: SpringBoot_MongoDB
 * @ClassName UserServiceImpl
 * @Author: liutao
 * @Description:
 * @Create: 2023-04-22 17:35
 * @Version 1.0
 **/

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository  userRepository;
    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public User insert(User user) {
//        return userRepository.insert(user);
        return mongoTemplate.insert(user);
    }

    @Override
    public User update(User user) {
        Query query = new Query(Criteria.where("id").is(user.getId()));
        Update update = new Update();
        if(!StringUtils.isEmpty(user.getUsername())) {
            update.set("username",user.getUsername());
        }
        if(!StringUtils.isEmpty(user.getPassword())) {
            update.set("password", user.getPassword());
        }
        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        return result.getModifiedCount() > 0? mongoTemplate.findById(user.getId(),User.class) : null;

    }

    @Override
    public List<User> findAll() {
        return mongoTemplate.findAll(User.class);
    }

    @Override
    public User findById(String id) {
        return mongoTemplate.findById(id,User.class);
    }

    @Override
    public Boolean deleteById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        return mongoTemplate.remove(query,User.class).getDeletedCount() > 0;
    }

    @Override
    public Boolean deleteByIds(List<String> ids) {
        return mongoTemplate.remove( new Query(Criteria.where("id").in(ids)),User.class).getDeletedCount() > 0;
    }

    @Override
    public HashMap<String,Object> findPage(Integer pageNum, Integer pageSize) {
        HashMap<String,Object> map = new HashMap<>(10);
        Query query = new Query();
        map.put("total",mongoTemplate.count(query, User.class));
        query.skip((pageNum - 1) * pageSize);
        query.limit(pageSize);
        List<User> users = mongoTemplate.find(query, User.class);
        map.put("pageNum",pageNum);
        map.put("pageSize",pageSize);
        map.put("data",users);
        return map;
    }
}

user web接口

import com.example.mongodb.common.Result;
import com.example.mongodb.entity.User;
import com.example.mongodb.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Program: SpringBoot_MongoDB
 * @ClassName TestController
 * @Author: liutao
 * @Description: 测试增删改查
 * @Create: 2023-04-22 17:22
 * @Version 1.0
 **/
@Api(tags = "用户接口")
@RequestMapping("/user")
@RestController
public class UserController {
    final static Logger log = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    @ApiOperation("增加或更新")
    @PostMapping
    public Result<User> save(@RequestBody User user) {
        User newUser = null;
        if (StringUtils.isEmpty(user.getId()){
            newUser = userService.insert(user);
        } else {
            newUser = userService.update(user);
        }
        return Result.success(newUser);
    }

    @ApiOperation("查询所有")
    @GetMapping
    public Result<User> findAll() {
        return Result.success(userService.findAll());
    }

    @ApiOperation("分页查询所有")
    @GetMapping("/page")
    public Result<User> findPage(@RequestParam Integer pageNum,
                                 @RequestParam Integer pageSize
    ) {
        return Result.success(userService.findPage(pageNum, pageSize));
    }

    @ApiOperation("通过id查询")
    @GetMapping("/{id}")
    public Result<User> findById(@PathVariable String id) {
        return Result.success(userService.findById(id));
    }

    @ApiOperation("删除")
    @DeleteMapping("/del/{id}")
    public Result<User> delete(@PathVariable String id) {
        return Result.success(userService.deleteById(id));
    }

    @ApiOperation("批量删除")
    @PostMapping("/del/batch")
    public Result<User> delete(@RequestBody List<String> ids) {
        log.info("delete batch:{}", ids);
        return Result.success(userService.deleteByIds(ids));
    }
}