SpringBoot2.x集成MongoDB，使用MongoTe
2020-12-02 本文已影响0人
Mark_ZSQ
1. 在pox.xml文件中添加spring-boot-starter-data-mongodb引用
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
2. 资源文件yml配置
#mysql配置
spring:
data:
mongodb:
uri: mongodb://127.0.0.1:38080/admin
3.实体
package msa.hdp.pojoMongo.orm;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import msa.hdp.pojoMongo.enums.TypeEnum;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
/**
* @author: ZSQ
* @Date: 2020/11/13 2:16 下午
* @Description: 传感器表
*/
@Data
@Document(collection="jSONObject")
public class Sensor {
@Id
@Field("_id")
private String _id;
/**
* 主键id
*/
@Field("id")
private String id;
/**
* 类型为 device-sensor
*/
private String type = TypeEnum.DEVICE_SENSOR.getKey();
/**
* 传感器类型id
*/
private String sensorTypeId;
/**
* 传感器类型code
*/
private String sensorTypeCode;
/**
* 监测区域id
*/
private String monitorAreaId;
/**
* 厂商id
*/
private Integer manufacturerId;
/**
* 网关id
*/
private String gateWayId;
/**
* 网关设备id
*/
private String gatewayDeviceId;
/**
* 协议id
*/
private Integer protocolId;
/**
* 厂商编码
*/
private String manufacturerCode;
/**
* 厂商名称
*/
private String manufacturerName;
/**
* 传感器自定义名称
*/
private String name;
/**
* 传感器code
*/
private String code;
/**
* 序号
*/
private String num;
/**
* 更新时间
*/
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private String updateTime;
/**
* 创建人
*/
private String createUser;
}
4. 构建和mongo交互业务封装基础类
package msa.hdp.webmongo.repository.base;
import lombok.extern.slf4j.Slf4j;
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.data.mongodb.repository.MongoRepository;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
/**
* @author: Mark.ZSQ
* @Date: 2020/11/26 3:18 下午
* @Description: mongoDB基础方法封装 实体类版
*/
@Slf4j
public abstract class MongoDbDao<T> {
/**
* 反射获取泛型类型
*
* @return
*/
protected abstract Class<T> getEntityClass();
@Autowired
private MongoTemplate mongoTemplate;
/***
* 保存一个对象
* @param t
*/
public void saveSingle(T t) {
log.info("-------------->MongoDB save start");
this.mongoTemplate.save(t);
}
/***
* 根据_id从几何中查询对象
* @param id
* @return
*/
public T queryByLineId(Integer id) {
Query query = new Query(Criteria.where("_id").is(id));
log.info("-------------->MongoDB queryByLineId start");
return this.mongoTemplate.findOne(query, this.getEntityClass());
}
/***
* 根据id从几何中查询对象
* @param id
* @return
*/
public T queryById(String id) {
Query query = new Query(Criteria.where("id").is(id));
log.info("-------------->MongoDB queryById start");
return this.mongoTemplate.findOne(query, this.getEntityClass());
}
/**
* 根据条件查询集合
*
* @param Object
* @return
*/
public List<T> queryList(T Object) {
Query query = getQueryByObject(Object);
log.info("-------------->MongoDB queryList start");
return mongoTemplate.find(query, this.getEntityClass());
}
/**
* 根据条件查询只返回一个文档
*
* @param Object
* @return
*/
public T queryOne(T Object) {
Query query = getQueryByObject(Object);
log.info("-------------->MongoDB find start");
return mongoTemplate.findOne(query, this.getEntityClass());
}
/***
* 根据条件分页查询
* @param Object
* @param start 查询起始值
* @param size 查询大小
* @return
*/
public List<T> getPage(T Object, int start, int size) {
Query query = getQueryByObject(Object);
query.skip(start);
query.limit(size);
log.info("-------------->MongoDB queryPage start");
return this.mongoTemplate.find(query, this.getEntityClass());
}
/***
* 根据条件查询库中符合条件的记录数量
* @param Object
* @return
*/
public Long getCount(T Object) {
Query query = getQueryByObject(Object);
log.info("-------------->MongoDB Count start");
return this.mongoTemplate.count(query, this.getEntityClass());
}
/***
* 删除对象
* @param t
* @return
*/
public int deleteSingle(T t) {
log.info("-------------->MongoDB delete start");
return (int) this.mongoTemplate.remove(t).getDeletedCount();
}
/**
* 根据id删除
*
* @param id
*/
public void deleteById(String id) {
Criteria criteria = Criteria.where("id").is(id);
if (null != criteria) {
Query query = new Query(criteria);
T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
log.info("-------------->MongoDB deleteById start");
if (obj != null) {
this.deleteSingle(obj);
}
}
}
/**
* 根据_id删除
*
* @param id
*/
public void deleteByLineId(Integer id) {
Criteria criteria = Criteria.where("_id").is(id);
if (null != criteria) {
Query query = new Query(criteria);
T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
log.info("-------------->MongoDB deleteById start");
if (obj != null) {
this.deleteSingle(obj);
}
}
}
/**
* 修改匹配到的第一条记录
*
* @param srcObj
* @param targetObj
*/
public void updateFirst(T srcObj, T targetObj) {
Query query = getQueryByObject(srcObj);
Update update = getUpdateByObject(targetObj);
log.info("-------------->MongoDB updateFirst start");
this.mongoTemplate.updateFirst(query, update, this.getEntityClass());
}
/***
* 修改匹配到的所有记录
* @param srcObj
* @param targetObj
*/
public void updateMulti(T srcObj, T targetObj) {
Query query = getQueryByObject(srcObj);
Update update = getUpdateByObject(targetObj);
log.info("-------------->MongoDB updateFirst start");
this.mongoTemplate.updateMulti(query, update, this.getEntityClass());
}
/***
* 修改匹配到的记录，若不存在该记录则进行添加
* @param srcObj
* @param targetObj
*/
public void updateInsert(T srcObj, T targetObj) {
Query query = getQueryByObject(srcObj);
Update update = getUpdateByObject(targetObj);
log.info("-------------->MongoDB updateInsert start");
this.mongoTemplate.upsert(query, update, this.getEntityClass());
}
/**
* 将查询条件对象转换为query
*
* @param Object
* @return
* @author Jason
*/
private Query getQueryByObject(T Object) {
Query query = new Query();
String[] fileds = getFiledName(Object);
Criteria criteria = new Criteria();
for (int i = 0; i < fileds.length; i++) {
String filedName = (String) fileds[i];
Object filedValue = getFieldValueByName(filedName, Object);
if (filedValue != null) {
criteria.and(filedName).is(filedValue);
}
}
query.addCriteria(criteria);
return query;
}
/**
* 将查询条件对象转换为update
*
* @param Object
* @return
* @author Jason
*/
private Update getUpdateByObject(T Object) {
Update update = new Update();
String[] fileds = getFiledName(Object);
for (int i = 0; i < fileds.length; i++) {
String filedName = (String) fileds[i];
Object filedValue = getFieldValueByName(filedName, Object);
if (filedValue != null) {
update.set(filedName, filedValue);
}
}
return update;
}
/***
* 获取对象属性返回字符串数组
* @param o
* @return
*/
private static String[] getFiledName(Object o) {
Field[] fields = o.getClass().getDeclaredFields();
String[] fieldNames = new String[fields.length];
for (int i = 0; i < fields.length; ++i) {
fieldNames[i] = fields[i].getName();
}
return fieldNames;
}
/***
* 根据属性获取对象属性值
* @param fieldName
* @param o
* @return
*/
private static Object getFieldValueByName(String fieldName, Object o) {
try {
String e = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + e + fieldName.substring(1);
Method method = o.getClass().getMethod(getter, new Class[0]);
return method.invoke(o, new Object[0]);
} catch (Exception var6) {
return null;
}
}
}
5. 创建dao层
/**
* @author: Mark.ZSQ
* @Date: 2020/11/26 2:20 下午
* @Description:
*/
@Component("mongoSensorRepository")
public class SensorMongoRepository extends MongoDbDao<Sensor> {
/**
* 实体返回
* @return
*/
@Override
protected Class<Sensor> getEntityClass() {
return Sensor.class;
}
}
6. 创建service抽象类
package msa.hdp.webmongo.service;
import msa.common.model.ResultModel;
import msa.hdp.pojoMongo.dto.sensor.CreateSensorDto;
import msa.hdp.pojoMongo.dto.sensor.UpdateSensorDto;
/**
* @author: Mark.ZSQ
* @Date: 2020/11/26 2:03 下午
* @Description:
*/
public interface SensorService {
ResultModel createSensor(CreateSensorDto createSensorDto);
ResultModel deleteSensor(String id);
ResultModel modifySensor(UpdateSensorDto updateSensorDto);
ResultModel getSensorList();
ResultModel getSensorById(String id);
ResultModel getNoMappingSensorListBySensorTypeId(String sensorTypeId);
}
7. 创建实现类
package msa.hdp.webmongo.service.impl;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import msa.common.model.DataTableVO;
import msa.common.model.PageModel;
import msa.common.model.ResultModel;
import msa.common.utils.ResultModelUtils;
import msa.hdp.common.exception.ServiceException;
import msa.hdp.common.exception.SystemException;
import msa.hdp.common.util.DateTimeUtil;
import msa.hdp.common.util.IdGenerator;
import msa.hdp.common.util.ObjCoverUtil;
import msa.hdp.pojo.orm.Manufacturer;
import msa.hdp.pojoMongo.dto.sensor.CreateSensorDto;
import msa.hdp.pojoMongo.dto.sensor.UpdateSensorDto;
import msa.hdp.pojoMongo.enums.TypeEnum;
import msa.hdp.pojoMongo.orm.DeviceMapping;
import msa.hdp.pojoMongo.orm.Sensor;
import msa.hdp.pojoMongo.orm.SensorType;
import msa.hdp.pojoMongo.vo.SensorVo;
import msa.hdp.web.repository.ManufacturerRepository;
import msa.hdp.webmongo.repository.DeviceMappingMongoRepository;
import msa.hdp.webmongo.repository.SensorMongoRepository;
import msa.hdp.webmongo.repository.SensorTypeMongoRepository;
import msa.hdp.webmongo.repository.base.DeviceRepository;
import msa.hdp.webmongo.service.SensorService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.transaction.Transactional;
import java.util.Comparator;
import java.util.List;
/**
* @author: Mark.ZSQ
* @Date: 2020/11/26 2:04 下午
* @Description:
*/
@Slf4j
@Service("mongoSensorService")
public class SensorServiceImpl implements SensorService {
@Resource(name = "mongoSensorRepository")
private SensorMongoRepository sensorMongoRepository;
@Autowired
MongoTemplate mongoTemplate;
@Transactional
@Override
public ResultModel createSensor(CreateSensorDto createSensorDto) {
log.info("createSensor --> {}");
sensorMongoRepository.saveSingle(sensor);
return ResultModelUtils.getSuccessInstance("添加传感器成功");
}
@Transactional
@Override
public ResultModel deleteSensor(String id) {
log.info("deleteSensor --> {}");
sensorMongoRepository.deleteById(id);
return ResultModelUtils.getSuccessInstance("删除传感器成功");
}
@Transactional
@Override
public ResultModel modifySensor(UpdateSensorDto updateSensorDto) {
log.info("modifySensor --> {}");
Sensor sensorSrc = new Sensor();
sensorSrc.setId(updateSensorDto.getId());
Sensor sensorTar = ObjCoverUtil.sourceToTarget(updateSensorDto, Sensor.class);
sensorMongoRepository.updateFirst(sensorSrc, sensorTar);
return ResultModelUtils.getSuccessInstance("修改传感器成功");
}
@Override
public ResultModel getSensorList() {
log.info("getSensorList --> {}");
List<Sensor> sensorList = Lists.newArrayList();
try {
Sensor param = new Sensor();
sensorList = sensorMongoRepository.queryList(param);
} catch (Exception e) {
log.error("查询传感器列表失败", e.getMessage());
throw new SystemException("查询传感器列表失败");
}
return ResultModelUtils.getSuccessInstance(sensorList);
}
@Override
public ResultModel getSensorById(String id) {
log.info("getSensorById --> {}");
Sensor sensor;
try {
sensor = sensorMongoRepository.queryById(id);
} catch (Exception e) {
log.error("查询传感器详情失败", e.getMessage());
throw new RuntimeException("查询传感器详情失败");
}
SensorVo sensorVo = ObjCoverUtil.sourceToTarget(sensor, SensorVo.class);
return ResultModelUtils.getSuccessInstance(sensorVo);
}
}
封装的基类, 以此在上自己进行封装
1.基于原生直接操作JSONObject这个document, 进行增删改查
package msa.hdp.webmongo.repository.base;
import com.alibaba.fastjson.JSONObject;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
/**
* @author: Mark.ZSQ
* @Date: 2020/11/26 2:20 下午
* @Description: 操作设备mongo库 json版
*/
@Repository
public interface DeviceRepository extends MongoRepository<JSONObject, String> {
}
2.基于自己封装直接操作JSONObject这个document, 进行增删改查, 目前发现存留问题
/**
* @author: Mark.ZSQ
* @Date: 2020/11/27 2:51 下午
* @Description: JSON扩展查询
*/
@Repository
public class JsonParamMongoDbDao extends MongoDbDao<JSONObject>{
@Override
protected Class<JSONObject> getEntityClass() {
return JSONObject.class;
}
}
3. 基于自定义实体封装操作mongo基类
package msa.hdp.webmongo.repository.base;
import lombok.extern.slf4j.Slf4j;
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.data.mongodb.repository.MongoRepository;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
/**
* @author: Mark.ZSQ
* @Date: 2020/11/26 3:18 下午
* @Description: mongoDB基础方法封装 实体类版
*/
@Slf4j
public abstract class MongoDbDao<T> {
/**
* 反射获取泛型类型
*
* @return
*/
protected abstract Class<T> getEntityClass();
@Autowired
private MongoTemplate mongoTemplate;
/***
* 保存一个对象
* @param t
*/
public void saveSingle(T t) {
log.info("-------------->MongoDB save start");
this.mongoTemplate.save(t);
}
/***
* 根据_id从几何中查询对象
* @param id
* @return
*/
public T queryByLineId(Integer id) {
Query query = new Query(Criteria.where("_id").is(id));
log.info("-------------->MongoDB queryByLineId start");
return this.mongoTemplate.findOne(query, this.getEntityClass());
}
/***
* 根据id从几何中查询对象
* @param id
* @return
*/
public T queryById(String id) {
Query query = new Query(Criteria.where("id").is(id));
log.info("-------------->MongoDB queryById start");
return this.mongoTemplate.findOne(query, this.getEntityClass());
}
/**
* 根据条件查询集合
*
* @param Object
* @return
*/
public List<T> queryList(T Object) {
Query query = getQueryByObject(Object);
log.info("-------------->MongoDB queryList start");
return mongoTemplate.find(query, this.getEntityClass());
}
/**
* 根据条件查询只返回一个文档
*
* @param Object
* @return
*/
public T queryOne(T Object) {
Query query = getQueryByObject(Object);
log.info("-------------->MongoDB find start");
return mongoTemplate.findOne(query, this.getEntityClass());
}
/***
* 根据条件分页查询
* @param Object
* @param start 查询起始值
* @param size 查询大小
* @return
*/
public List<T> getPage(T Object, int start, int size) {
Query query = getQueryByObject(Object);
query.skip(start);
query.limit(size);
log.info("-------------->MongoDB queryPage start");
return this.mongoTemplate.find(query, this.getEntityClass());
}
/***
* 根据条件查询库中符合条件的记录数量
* @param Object
* @return
*/
public Long getCount(T Object) {
Query query = getQueryByObject(Object);
log.info("-------------->MongoDB Count start");
return this.mongoTemplate.count(query, this.getEntityClass());
}
/***
* 删除对象
* @param t
* @return
*/
public int deleteSingle(T t) {
log.info("-------------->MongoDB delete start");
return (int) this.mongoTemplate.remove(t).getDeletedCount();
}
/**
* 根据id删除
*
* @param id
*/
public void deleteById(String id) {
Criteria criteria = Criteria.where("id").is(id);
if (null != criteria) {
Query query = new Query(criteria);
T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
log.info("-------------->MongoDB deleteById start");
if (obj != null) {
this.deleteSingle(obj);
}
}
}
/**
* 根据_id删除
*
* @param id
*/
public void deleteByLineId(Integer id) {
Criteria criteria = Criteria.where("_id").is(id);
if (null != criteria) {
Query query = new Query(criteria);
T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
log.info("-------------->MongoDB deleteById start");
if (obj != null) {
this.deleteSingle(obj);
}
}
}
/**
* 修改匹配到的第一条记录
*
* @param srcObj
* @param targetObj
*/
public void updateFirst(T srcObj, T targetObj) {
Query query = getQueryByObject(srcObj);
Update update = getUpdateByObject(targetObj);
log.info("-------------->MongoDB updateFirst start");
this.mongoTemplate.updateFirst(query, update, this.getEntityClass());
}
/***
* 修改匹配到的所有记录
* @param srcObj
* @param targetObj
*/
public void updateMulti(T srcObj, T targetObj) {
Query query = getQueryByObject(srcObj);
Update update = getUpdateByObject(targetObj);
log.info("-------------->MongoDB updateFirst start");
this.mongoTemplate.updateMulti(query, update, this.getEntityClass());
}
/***
* 修改匹配到的记录，若不存在该记录则进行添加
* @param srcObj
* @param targetObj
*/
public void updateInsert(T srcObj, T targetObj) {
Query query = getQueryByObject(srcObj);
Update update = getUpdateByObject(targetObj);
log.info("-------------->MongoDB updateInsert start");
this.mongoTemplate.upsert(query, update, this.getEntityClass());
}
/**
* 将查询条件对象转换为query
*
* @param Object
* @return
* @author Jason
*/
private Query getQueryByObject(T Object) {
Query query = new Query();
String[] fileds = getFiledName(Object);
Criteria criteria = new Criteria();
for (int i = 0; i < fileds.length; i++) {
String filedName = (String) fileds[i];
Object filedValue = getFieldValueByName(filedName, Object);
if (filedValue != null) {
criteria.and(filedName).is(filedValue);
}
}
query.addCriteria(criteria);
return query;
}
/**
* 将查询条件对象转换为update
*
* @param Object
* @return
* @author Jason
*/
private Update getUpdateByObject(T Object) {
Update update = new Update();
String[] fileds = getFiledName(Object);
for (int i = 0; i < fileds.length; i++) {
String filedName = (String) fileds[i];
Object filedValue = getFieldValueByName(filedName, Object);
if (filedValue != null) {
update.set(filedName, filedValue);
}
}
return update;
}
/***
* 获取对象属性返回字符串数组
* @param o
* @return
*/
private static String[] getFiledName(Object o) {
Field[] fields = o.getClass().getDeclaredFields();
String[] fieldNames = new String[fields.length];
for (int i = 0; i < fields.length; ++i) {
fieldNames[i] = fields[i].getName();
}
return fieldNames;
}
/***
* 根据属性获取对象属性值
* @param fieldName
* @param o
* @return
*/
private static Object getFieldValueByName(String fieldName, Object o) {
try {
String e = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + e + fieldName.substring(1);
Method method = o.getClass().getMethod(getter, new Class[0]);
return method.invoke(o, new Object[0]);
} catch (Exception var6) {
return null;
}
}
}
