前言
为了简化java代码操作mongodb 数据库库，仿mybatis-plus风格封装了mongodb 工具类。
教程
以下是仿照mybatis-plus风格操作 mongodb 的增删改查的工具类以及使用示例
pom文件引入依赖
<!-- mongodb -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version> 1.2.70</version>
</dependency>
<!-- mybatis-plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.2</version>
</dependency>MongoDBUtil 工具类代码
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.mongodb.client.result.UpdateResult;
import org.springblade.core.tool.utils.SpringUtil;
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.*;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public class MongoDBUtil {
private static final Query EMPTY_QUERY = new BasicQuery("{}");
private static final MongoTemplate template;
static {
template = SpringUtil.getBean(MongoTemplate.class);
}
private static Query idEqQuery(Serializable id) {
Criteria criteria = Criteria.where("id").is(id);
return Query.query(criteria);
}
private static Query idInQuery(Collection<? extends Serializable> idList) {
Criteria criteria = Criteria.where("id").in(idList);
return Query.query(criteria);
}
private static Query eqQuery(Map<String, Object> data) {
if (CollectionUtils.isEmpty(data)) {
return EMPTY_QUERY;
} else {
Criteria criteria = new Criteria();
data.forEach((k, v) -> criteria.and(k).is(v));
return Query.query(criteria);
}
}
private static <T> Serializable getIdValue(T entity) {
try {
Field field = entity.getClass().getDeclaredField("id");
field.setAccessible(true);
return (Serializable) field.get(entity);
} catch (NoSuchFieldException | IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
private static <T> Update getUpdate(T entity) {
Field[] fields = entity.getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
try {
System.out.println(field.getName()+" "+field.get(entity));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return null;
}
public static <T> void save(T entity) {
template.save(entity);
}
public static <T> void saveBatch(Collection<T> entityList) {
template.insertAll(entityList);
}
public static void removeById(Serializable id, Class<?> clazz) {
template.remove(idEqQuery(id), clazz);
}
public static void removeByMap(Map<String, Object> columnMap, Class<?> clazz) {
template.remove(eqQuery(columnMap), clazz);
}
public static void removeByIds(Collection<? extends Serializable> idList, Class<?> clazz) {
template.remove(idInQuery(idList), clazz);
}
public static void remove(Query query, Class<?> clazz) {
template.remove(query, clazz);
}
public static <T> boolean updateById(T entity) {
Assert.notNull(entity, "entity must not be null!");
JSONObject obj = (JSONObject) JSONObject.toJSON(entity);
DBObject update = new BasicDBObject();
update.put("$set", obj);
UpdateResult result = template.updateFirst(idEqQuery(getIdValue(entity)), new BasicUpdate(update.toString()), entity.getClass());
return result.getModifiedCount() == 1L;
}
public static <T> void updateBatchById(Collection<T> entityList) {
entityList.forEach(e -> updateById(e));
}
public static void update(Query query, Update update, Class<?> clazz) {
template.updateMulti(query, update, clazz);
}
public static <T> void saveOrUpdate(T entity) {
Assert.notNull(entity, "entity must not be null!");
String key = JSONObject.toJSONString(entity);
Update inc = new Update().inc(key, 1);
template.upsert(idEqQuery(getIdValue(entity)), inc, entity.getClass());
}
public static <T> void saveOrUpdateBatch(Collection<T> entityList) {
entityList.forEach(MongoDBUtil::saveOrUpdate);
}
public static <T> T getById(Serializable id, Class<T> clazz) {
return template.findById(id, clazz);
}
public static <T> T getOne(Query query, Class<T> clazz) {
return template.findOne(query, clazz);
}
public static <T> List<T> listByIds(Collection<? extends Serializable> idList, Class<T> clazz) {
return template.find(idInQuery(idList), clazz);
}
public static <T> List<T> listByMap(Map<String, Object> columnMap, Class<T> clazz) {
return template.find(eqQuery(columnMap), clazz);
}
public static <T> List<T> list(Class<T> clazz) {
return template.findAll(clazz);
}
public static <T> List<T> list(Query query, Class<T> clazz) {
return template.find(query, clazz);
}
public static <T> long count(Class<T> clazz) {
return template.count(EMPTY_QUERY, clazz);
}
public static <T> long count(Query query, Class<T> clazz) {
return template.count(query, clazz);
}
public static <T> IPage<T> page(IPage page, Class<T> clazz) {
page.setTotal(count(clazz));
Pageable pageable = PageRequest.of((int) (page.getCurrent()+1), (int) page.getSize());
List<T> records = template.find(new Query().with(new Sort(Sort.Direction.DESC, "id")).with(pageable), clazz);
page.setPages(page.getPages());
page.setRecords(records);
return page;
}
public static <T> IPage<T> page(IPage page, Query query, Class<T> clazz) {
page.setTotal(count(query, clazz));
Pageable pageable = PageRequest.of((int) (page.getCurrent()+1), (int) page.getSize());
List<T> records = template.find(query.with(pageable), clazz);
page.setPages(page.getPages());
page.setRecords(records);
return page;
}
}
测试用例代码
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.secure.annotation.NoToken;
import org.springblade.core.tool.api.R;
import org.springblade.workface.modules.automate.Inertialnavigation.entity.InertialNavigation;
import org.springblade.workface.util.MongoDBUtil;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@AllArgsConstructor
@RequestMapping("inertialNavigation")
@Api(value = "惯导数据mongo测试", tags = "惯导数据mongo测试")
@NoToken
public class InertialNavigationController {
@PostMapping("/save")
@ApiOperation(value = "新增")
private R<Boolean> save(@RequestBody InertialNavigation dto){
MongoDBUtil.save(dto);
return R.status(true);
}
@PostMapping("/update")
@ApiOperation(value = "修改")
private R<Boolean> update(@RequestBody InertialNavigation dto){
return R.status(MongoDBUtil.updateById(dto));
}
@PostMapping("/remove")
@ApiOperation(value = "删除")
private R<Boolean> remove(@RequestBody List<Long> ids){
MongoDBUtil.removeByIds(ids,InertialNavigation.class);
return R.status(true);
}
@PostMapping("/list")
@ApiOperation(value = "查询")
private R<List<InertialNavigation>> list(){
return R.data(MongoDBUtil.list(InertialNavigation.class));
}
@GetMapping("/get/{id}")
@ApiOperation(value = "详情")
private R<InertialNavigation> get(@PathVariable("id") Long id){
return R.data(MongoDBUtil.getById(id, InertialNavigation.class));
}
@PostMapping("/page")
@ApiOperation(value = "分页")
private R<IPage<InertialNavigation>> page(@RequestBody Query query){
return R.data(MongoDBUtil.page(Condition.getPage(query),InertialNavigation.class));
}
}
InertialNavigation 代码
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
@Data
public class InertialNavigation {
private Long id;
/** 支架数量 */
private Integer zjsl;
private Integer receivedFrame;
private Integer sentFrame;
private String zjh;
/** 采煤机当前所在液压支架号 */
private String zgbh;
private BigDecimal speedResource;
private Integer pingFlag;
private String workTime;
private Date startDate;
private Integer direction;
private InertialNavigationData newestResource;
}
InertialNavigationData 代码
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.math.BigDecimal;
import java.util.Date;
/**
* 惯导数据实体类
*
* @version 1.0
* @since JDK1.8
* @author tarzan
* @date 2022年01月29日 14:42:04
*/
@Data
public class InertialNavigationData {
/** 主键 */
private Long id;
/** 惯导id */
private Long InertialNavigationId;
/** 基准x坐标 */
private BigDecimal baseX;
/** 基准y坐标 */
private BigDecimal baseY;
/** 基准z坐标 */
private BigDecimal baseZ;
/** x坐标 */
private BigDecimal x;
/** y坐标 */
private BigDecimal y;
/** z坐标 */
private BigDecimal z;
/** 计算x坐标 */
private BigDecimal computeX;
/** 计算y坐标 */
private BigDecimal computeY;
/** 计算z坐标 */
private BigDecimal computeZ;
private String guandaoType;
private String guandaoTypeName;
private String guandaoStatus;
private String guandaoStatusName;
private String gpsEnable;
private String totalIndex;
private BigDecimal fuyang;
private BigDecimal henggong;
private BigDecimal hangxiang;
private String lcjs;
/** 时间 */
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createDate;
/** 时间 */
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateDate;
}
相关知识
MongoDB
MongoDB是一种开源的、面向文档的NoSQL数据库管理系统，它使用了由键值对组成的BSON(Binary JSON)格式来存储数据。MongoDB以其灵活性、可伸缩性和容错特性而闻名于世。
1. 数据模型： MongoDB采用文档数据库模型，即将数据存储在一个称为文档的结构化记录中。文档可以是JSON、BSON等格式，不需要遵循固定的模式，这使得MongoDB非常适合处理半结构化和多变的数据。文档的字段可以包含子文档、数组和其他复杂类型。
2. 查询语言和索引： MongoDB提供了强大的查询语言，支持各种操作符和函数，可以进行复杂的查询和聚合操作。同时，MongoDB内置了多种类型的索引（例如B树索引、地理空间索引等），以加快查询速度并优化性能。
3. 可扩展性和分布式架构： MongoDB具有良好的可扩展性，可以轻松地通过添加更多的节点来实现集群化，并自动分布数据到各个节点上。通过在多个节点上进行数据复制，还可以提高系统的可靠性和容错性。
4. 高性能： MongoDB支持以写入驱动和读取驱动的方式进行数据访问，可以根据应用程序的需求选择合适的读写策略。在写入方面，MongoDB支持快速的批量写操作，可以将大量的文档一次性插入或更新到数据库中。在读取方面，MongoDB的查询引擎使用了各种优化技术（如索引和查询计划优化），以提供高效的查询性能。
5. 安全性： MongoDB提供了多种安全机制来保护数据库的数据和访问权限。可以通过身份验证、访问控制、加密传输等方式来确保数据的机密性和完整性。此外，MongoDB还支持审计功能，记录所有与数据库相关的操作和事件。
6. 社区和生态系统： MongoDB拥有一个活跃的开源社区，提供了丰富的工具和第三方库，以及大量的文档和教程。这使得开发人员能够更轻松地学￥和使用MongoDB，并解决遇到的问题。
总结起来，MongoDB是一款适用于处理半结构化和多变的数据的强大数据库管理系统。它具有灵活性、可伸缩性、强大的查询语言和索引、高性能、安全性以及活跃的社区支持等特点，广泛应用于Web应用程序、大数据分析、实时分析等场景中。
spring-boot-starter-data-mongodb
spring-boot-starter-data-mongodb是Spring Boot提供的用于集成MongoDB数据库的起步依赖。它简化了在Spring Boot应用程序中使用MongoDB的配置和操作，提供了一系列预配置的类和方法，使得开发人员可以更轻松地进行MongoDB的数据访问和操作。以下是关于spring-boot-starter-data-mongodb的详细解释：
-
配置简化：
spring-boot-starter-data-mongodb通过自动配置功能，减少了手动配置的工作量。只需在application.properties或application.yml文件中添加相应的配置属性，即可完成与MongoDB的连接。 -
MongoDB模板（MongoTemplate）：该起步依赖提供了MongoTemplate类，用于执行各种MongoDB操作，如插入文档、更新文档、查询文档等。MongoTemplate封装了MongoDB原生驱动的操作，使得操作更加简洁和方便。
-
Repository支持：
spring-boot-starter-data-mongodb还集成了Spring Data MongoDB，可以通过接口方式定义Repository，并自动生成对应的实现类。这样，开发人员只需编写Repository接口，无需编写实现逻辑即可完成基本的CRUD操作。 -
实体映射：支持使用注解将Java实体类映射到MongoDB中的文档（Document），简化了实体与文档之间的转换和操作过程。
-
插件扩展：
spring-boot-starter-data-mongodb为MongoDB提供了丰富的插件扩展机制，可以根据需要添加和使用各种插件，如查询注解、聚合操作等。 -
数据验证和转换：该起步依赖支持数据验证和转换功能，可以通过注解方式定义字段级别的验证规则，并提供了一系列内置的数据转换器，用于在文档和实体之间进行数据转换。
总结：
spring-boot-starter-data-mongodb是Spring Boot提供的用于集成MongoDB数据库的起步依赖。它使得在Spring Boot应用程序中使用MongoDB变得更加简单和高效，提供了预配置的类和方法，简化了MongoDB的数据访问和操作。通过学习和掌握spring-boot-starter-data-mongodb的特性和用法，开发人员可以更好地利用Spring Boot和MongoDB构建强大的应用程序。然而，深入理解和熟练应用spring-boot-starter-data-mongodb还需要进一步的学习和实践，请根据实际需求和情况不断探索和扩展您对其的认识和应用能力。
353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
