mongodb书籍_SpringBoot2.x集成MongoDB，强化版范型CRUD操作

享学课堂特邀作者：老顾 转载请声明出处！！！

前言

MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。

什么是NoSQL?

NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。

NoSQL用于超大规模数据的存储。（例如谷歌或Facebook每天为他们的用户收集万亿比特的数据）。这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。

基本概念

不管我们学习什么数据库都应该学习其中的基础概念，在mongodb中基本的概念是文档、集合、数据库，下面我们挨个介绍。

下表将帮助您更容易理解Mongo中的一些概念

通过下图实例，我们也可以更直观的了解Mongo中的一些概念：

关于如何部署mongodb，以及相关的基本概念，老顾就不在这里介绍了，小伙伴们可以自行上网学习。

今天老顾直接带着大家如何在SpringBoot中操作MongoDB；类似操作mysql。

相关配置

在pox.xml文件中添加spring-boot-starter-data-mongodb引用

org.springframework.boot spring-boot-starter-data-mongodb

配置yml文件

spring:
  data:
    mongodb:
      host: localhost
      port: 27017
      database: rainbow

创建实体类

书籍类

用户类

创建service类

Service中主要来实现CURD的操作

此处需要说明的是Mongodb的修改操作大致有3种：

• mongoTemplate.updateFirst操作：修改第一条
• mongoTemplate.updateMulti操作：修改符合条件的所有
• this.mongoTemplate.upsert操作：修改时如果不存在则添加.

@Service
public class BookMongoDbService {
  private static final Logger logger = LoggerFactory.getLogger(BookMongoDbService.class);
  
  @Autowired
    private MongoTemplate mongoTemplate;
  
  /**
     * 保存对象
     *
     * @param book
     * @return
     */
    public String saveObj(Book book) {
        logger.info("--------------------->[MongoDB save start]");
        
        book.setCreateTime(LocalDateTime.now());
        book.setUpdateTime(LocalDateTime.now());
        mongoTemplate.save(book);
        return "添加成功";
    }
    /**
     * 查询所有
     *
     * @return
     */
    public List<Book> findAll() {
        logger.info("--------------------->[MongoDB find start]");
        return mongoTemplate.findAll(Book.class);
    }
​
    /***
     * 根据id查询
     * @param id
     * @return
     */
    public Book getBookById(String id) {
        logger.info("--------------------->[MongoDB find start]");
        Query query = new Query(Criteria.where("_id").is(id));
        return mongoTemplate.findOne(query, Book.class);
    }
    /**
     * 根据名称查询
     *
     * @param name
     * @return
     */
    public Book getBookByName(String name) {
        logger.info("--------------------->[MongoDB find start]");
        Query query = new Query(Criteria.where("name").is(name));
        return mongoTemplate.findOne(query, Book.class);
    }
    /**
     * 更新对象
     *
     * @param book
     * @return
     */
    public String updateBook(Book book) {
        logger.info("--------------------->[MongoDB update start]");
        Query query = new Query(Criteria.where("_id").is(book.getId()));
        Update update = new Update().set("publish", book.getPublish())
                .set("info", book.getInfo())
                .set("updateTime", new Date());
        //updateFirst 更新查询返回结果集的第一条
        mongoTemplate.updateFirst(query, update, Book.class);
        //updateMulti 更新查询返回结果集的全部
//        mongoTemplate.updateMulti(query,update,Book.class);
        //upsert 更新对象不存在则去添加
//        mongoTemplate.upsert(query,update,Book.class);
        return "success";
    }
    /***
     * 删除对象
     * @param book
     * @return
     */
    public String deleteBook(Book book) {
        logger.info("--------------------->[MongoDB delete start]");
        mongoTemplate.remove(book);
        return "success";
    }
    /**
     * 根据id删除
     *
     * @param id
     * @return
     */
    public String deleteBookById(String id) {
        logger.info("--------------------->[MongoDB delete start]");
        //findOne
        Book book = getBookById(id);
        //delete
        deleteBook(book);
        return "success";
    }
}

创建控制器Controller

@RestController
public class BookController {
  @Autowired
    private BookMongoDbService bookMongoDbService;
    @PostMapping("/mongo/save")
    public String saveObj(@RequestBody Book book) {return bookMongoDbService.saveObj(book);}
    @GetMapping("/mongo/findAll")
    public List<Book> findAll() {return bookMongoDbService.findAll();}
    @GetMapping("/mongo/findOne")
    public Book findOne(@RequestParam String id) {return bookMongoDbService.getBookById(id);}
    @GetMapping("/mongo/findOneByName")
    public Book findOneByName(@RequestParam String name) {return bookMongoDbService.getBookByName(name);}
    @PostMapping("/mongo/update")
    public String update(@RequestBody Book book) {return bookMongoDbService.updateBook(book);}
    @PostMapping("/mongo/delOne")
    public String delOne(@RequestBody Book book) {return bookMongoDbService.deleteBook(book);}
    @GetMapping("/mongo/delById")
    public String delById(@RequestParam String id) {return bookMongoDbService.deleteBookById(id);}
}

启动测试

启动postman

查看monogoDb数据库

优化使用

我们看到上面的操作monogoDb的CRUD操作，是使用了MongoTemplate对象的方法，里面有很多CRUD的方法。但是在使用中会发现一个问题，假如要对数据库操作多个对象，那岂不是每一个对象Service都需要写一套增删查改的方法

那能不能有像mysql操作的mybatis-plus操作方式，可以很方便，快速的操作monogoDb数据库呢？

老顾就来分享一下如何做？

定义MongoDbDao抽象类

上面的MongoDbDao抽象类，就是封装了对实体类的CRUD操作。我们还需要定义service类，提供给上层业务去使用。

定义MongoDbService抽象类

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.rainbow.demo.dao.MongoDbDao;
public abstract class MongoDbService<T> {
  @Autowired
    private MongoDbDao<T> mongoDbDao;
  /***
     * 保存一个对象
     * @param t
     */
    public void save(T t) {
        this.mongoDbDao.save(t);
    }
    /***
     * 根据id从几何中查询对象
     * @param id
     * @return
     */
    public T queryById(String id) {
        return mongoDbDao.queryById(id);
    }
    /**
     * 根据条件查询集合
     *
     * @param object
     * @return
     */
    public List<T> queryList(T object) {
        return mongoDbDao.queryList(object);
    }
    /**
     * 根据条件查询只返回一个文档
     *
     * @param object
     * @return
     */
    public T queryOne(T object) {
       return mongoDbDao.queryOne(object);
    }
    /***
     * 根据条件分页查询
     * @param object
     * @param start 查询起始值
     * @param size  查询大小
     * @return
     */
    public List<T> getPage(T object, int start, int size) {
        return mongoDbDao.getPage(object, start, size);
    }
    /***
     * 根据条件查询库中符合条件的记录数量
     * @param object
     * @return
     */
    public Long getCount(T object) {
        return mongoDbDao.getCount(object);
    }
    /***
     * 删除对象
     * @param t
     * @return
     */
    public int delete(T t) {
      return mongoDbDao.delete(t);
    }
    /**
     * 根据id删除
     *
     * @param id
     */
    public void deleteById(Integer id) {
      mongoDbDao.deleteById(id);
    }
    /**
     * 修改匹配到的第一条记录
     * @param srcObj
     * @param targetObj
     */
    public void updateFirst(T srcObj, T targetObj){
        this.mongoDbDao.updateFirst(srcObj, targetObj);
    }
    /***
     * 修改匹配到的所有记录
     * @param srcObj
     * @param targetObj
     */
    public void updateMulti(T srcObj, T targetObj){
        this.mongoDbDao.updateMulti(srcObj, targetObj);
    }
    /***
     * 修改匹配到的记录，若不存在该记录则进行添加
     * @param srcObj
     * @param targetObj
     */
    public void updateInsert(T srcObj, T targetObj){
      mongoDbDao.updateInsert(srcObj, targetObj);
    }
}

到这里我们的抽象类就完成了，那如何使用呢？就很简单了。

定义实体类Dao

图书实体操作Dao类，只要继承MongoDbDao就行了，当然需要重写getEntityClass

import org.springframework.stereotype.Repository;
import com.rainbow.demo.domain.Book;
@Repository
public class BookMongoDbDao extends MongoDbDao<Book> {
  @Override
  protected Class<Book> getEntityClass() {
    return Book.class;
  }
}

雇佣实体操作Dao，只要继承MongoDbDao就行了，当然需要重写getEntityClass

import org.springframework.stereotype.Repository;
import com.rainbow.demo.domain.Emp;
@Repository
public class EmpMongoDbDao extends MongoDbDao<Emp> {
  @Override
  protected Class<Emp> getEntityClass() {
    return Emp.class;
  }
}

定义实体类Service

Book实体Service，只要继承MongoDbService<Book>

import org.springframework.stereotype.Service;
import com.rainbow.demo.domain.Book;
@Service
public class BookMongoDbPlusService extends MongoDbService<Book> {
}

Emp实体Service，只要继承MongoDbService<Emp>

import org.springframework.stereotype.Service;
import com.rainbow.demo.domain.Emp;
@Service
public class EmpMongoDbPlusService extends MongoDbService<Emp> {
}

控制类改造

@RestController
public class BookPlusController {
  @Autowired
    private BookMongoDbPlusService bookMongoDbPlusService;
    @PostMapping("/plus/mongo/save")
    public void saveObj(@RequestBody Book book) { bookMongoDbPlusService.save(book);}
}

是不是整体很方便，只要继承相关的抽象类，就可以完成基本的CRUD操作了。

番外篇

我们发现实体类Book中定义了LocalDateTime属性

我们用postman请求

传入日期 "createTime": "2014-01-01T01:00:00"， 后台可以接收

传入"createTime": "2014-01-01 01:00:00"， 页面有如下异常信息

JSON parse error: Can not deserialize value of type java.time.LocalDateTime from String

本文中用的序列化方式为：

Maven: com.fasterxml.jackson.core:jackson-databind:2.8.8

@Bean
    public ObjectMapper objectMapper() {
        bjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(new Jdk8Module());
        objectMapper.registerModule(new JavaTimeModule());
        objectMapper.registerModule(new GuavaModule());
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    }

为什么传2014-01-01T01:00:00 这个字符串可以被后台解析呢？ 原因在JavaTimeModule类中：

默认配置对LocalDateTime配置序列化和反序列化类

LocalDateTimeSerializer类默认日期格式，有个 T 拼接字符，问题就出在这里，所以2014-01-01 01:00:00后台反序列化失败

解决方案：自己指定日期解析格式

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new Jdk8Module());
JavaTimeModule module = new JavaTimeModule();
module.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
module.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
objectMapper.registerModule(module);

总结

以上就是springboot与mongoDB集成环境的初步搭建，今天就分享到这里了，谢谢！！！