SpringBoot2.x集成MongoDB，强化版范型CRUD
2020-11-13 本文已影响0人
享学课堂
享学课堂特邀作者：老顾
转载请声明出处！！！
前言
MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。
什么是NoSQL?
NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。
NoSQL用于超大规模数据的存储。（例如谷歌或Facebook每天为他们的用户收集万亿比特的数据）。这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。
基本概念
不管我们学习什么数据库都应该学习其中的基础概念，在mongodb中基本的概念是文档、集合、数据库，下面我们挨个介绍。
下表将帮助您更容易理解Mongo中的一些概念
img
通过下图实例，我们也可以更直观的了解Mongo中的一些概念：
img
关于如何部署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
创建实体类
书籍类
img
用户类
img
创建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
img
查看monogoDb数据库
img
优化使用
我们看到上面的操作monogoDb的CRUD操作，是使用了MongoTemplate对象的方法，里面有很多CRUD的方法。但是在使用中会发现一个问题，假如要对数据库操作多个对象，那岂不是每一个对象Service都需要写一套增删查改的方法
那能不能有像mysql操作的mybatis-plus操作方式，可以很方便，快速的操作monogoDb数据库呢？
老顾就来分享一下如何做？
定义MongoDbDao抽象类
img
img
img
img
img
img
img
img
上面的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配置序列化和反序列化类
img
LocalDateTimeSerializer类默认日期格式，有个 T 拼接字符，问题就出在这里，所以2014-01-01 01:00:00后台反序列化失败
img
解决方案：自己指定日期解析格式
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集成环境的初步搭建，今天就分享到这里了，谢谢！！！
img
