1.移除无用的测试接口类和mongodb模板

2.删除mongodb依赖,调整sql性能分析插件打包配置
master
x_z 3 years ago
parent 96635bb435
commit d860a9f444

@ -110,6 +110,7 @@
<groupId>p6spy</groupId>
<artifactId>p6spy</artifactId>
<version>3.9.1</version>
<scope>provided</scope>
</dependency>
@ -127,12 +128,6 @@
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
@ -144,11 +139,6 @@
<version>2.13.3</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>

@ -1,199 +0,0 @@
package com.glxp.udi.admin.controller;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.glxp.udi.admin.dao.inout.*;
import com.glxp.udi.admin.entity.inout.*;
import com.glxp.udi.admin.entity.mongo.*;
import com.glxp.udi.admin.mongo.dao.*;
import com.glxp.udi.admin.service.inout.UdiInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
/**
* todo 线
*/
@Slf4j
@RestController
public class TestController {
@Resource
private UdiInfoDao udiInfoDao;
//mongodb dao
@Resource
private OrderMdDao orderMdDao;
@Resource
private OrderDetailMdDao orderDetailMdDao;
@Resource
private CodesMdDao codesMdDao;
@Resource
private CodesTempMdDao codesTempMdDao;
@Resource
private InvProductMdDao invProductMdDao;
@Resource
private InvProductDetailMdDao invProductDetailMdDao;
//mysql dao
@Resource
private OrderDao orderDao;
@Resource
private OrderDetailDao orderDetailDao;
@Resource
private CodesDao codesDao;
@Resource
private CodesTempDao codesTempDao;
@Resource
private InvProductDao invProductDao;
@Resource
private InvProductDetailDao invProductDetailDao;
@Resource
private UdiInfoService udiInfoService;
/**
* relIdID
*
* @return
*/
@GetMapping("/test/refreshOrderData")
private String refreshOrderData() {
try {
//刷新码详情数据
List<WarehouseEntity> warehouseEntities = codesDao.selectList(null);
warehouseEntities.forEach(code -> {
UdiInfoEntity udiInfoEntity = udiInfoDao.selectById(code.getRelId());
try {
code.setRelId(udiInfoEntity.getUuid());
codesDao.updateById(code);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
});
//刷新临时码表
List<WarehousetempEntity> warehousetempEntities = codesTempDao.selectList(null);
warehousetempEntities.forEach(codesTemp -> {
UdiInfoEntity udiInfoEntity = udiInfoDao.selectById(codesTemp.getRelId());
codesTemp.setRelId(udiInfoEntity.getUuid());
codesTempDao.updateById(codesTemp);
});
return "success";
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return "error";
}
/**
* mongodbmysql
*
* @return
*/
@GetMapping("/test/copyData")
public String copyData() {
try {
log.info("开始拷贝单据数据");
List<OrderMdEntity> orderList = orderMdDao.getOrderList();
if (CollUtil.isNotEmpty(orderList)) {
orderList.forEach(orderMdEntity -> {
OrderEntity orderEntity = new OrderEntity();
BeanUtil.copyProperties(orderMdEntity, orderEntity);
orderDao.insert(orderEntity);
});
}
log.info("单据数据拷贝完成");
log.info("开始拷贝单据详情数据");
List<ErpOrderEntity> orderDetailList = orderDetailMdDao.getOrderDetailList();
if (CollUtil.isNotEmpty(orderDetailList)) {
orderDetailList.forEach(orderMdDetail -> {
OrderDetailEntity orderDetailEntity = new OrderDetailEntity();
BeanUtil.copyProperties(orderMdDetail, orderDetailEntity, "id");
orderDetailEntity.setBatchNo(orderMdDetail.getLotno());
orderDetailEntity.setProductName(orderMdDetail.getCoName());
orderDetailEntity.setZczbhhzbapzbh(orderMdDetail.getAuthCode());
orderDetailEntity.setGgxh(orderMdDetail.getPackSpec());
orderDetailDao.insert(orderDetailEntity);
});
}
log.info("单据详情数据拷贝完成");
log.info("开始拷贝码数据");
List<WarehouseMdEntity> codesList = codesMdDao.getCodesList();
if (CollUtil.isNotEmpty(codesList)) {
codesList.forEach(code -> {
WarehouseEntity warehouseEntity = new WarehouseEntity();
BeanUtil.copyProperties(code, warehouseEntity, "id");
String actDate = warehouseEntity.getActDate();
if (StrUtil.isNotBlank(actDate)) {
String date = DateUtil.parse(actDate).toString("yyyy-MM-dd HH:mm:ss");
warehouseEntity.setActDate(date);
}
warehouseEntity.setNameCode(code.getUdi());
codesDao.insert(warehouseEntity);
});
}
log.info("码数据拷贝完成");
log.info("开始拷贝临时码表");
List<WarehousetempMdEntity> codesTempList = codesTempMdDao.getCodesTempList();
if (CollUtil.isNotEmpty(codesTempList)) {
codesTempList.forEach(codesTemp -> {
WarehousetempEntity warehousetempEntity = new WarehousetempEntity();
BeanUtil.copyProperties(codesTemp, warehousetempEntity, "id");
warehousetempEntity.setNameCode(codesTemp.getUdi());
codesTempDao.insert(warehousetempEntity);
});
}
log.info("临时码表数据拷贝完成");
log.info("开始拷贝库存数据");
List<InvProductMdEntity> invList = invProductMdDao.getInvList();
if (CollUtil.isNotEmpty(invList)) {
invList.forEach(inv -> {
InvProductEntity invProductEntity = new InvProductEntity();
BeanUtil.copyProperties(inv, invProductEntity, "id");
if (StrUtil.isNotBlank(inv.getProductionDate())) {
invProductEntity.setProductDate(inv.getProductionDate());
}
invProductDao.insert(invProductEntity);
if (StrUtil.isNotBlank(invProductEntity.getId())) {
//拷贝;临时码表的数据
log.info("开始拷贝临时码表数据");
//查询此库存对应的库存详情根据已经插入到mysql的数据生成mysql的库存详情数据
List<InvProductDetailMdEntity> invDetailList = invProductDetailMdDao.getInvDetailList(inv.getId());
if (CollUtil.isNotEmpty(invDetailList)) {
invDetailList.forEach(invDetail -> {
InvProductDetailEntity invProductDetailEntity = new InvProductDetailEntity();
BeanUtil.copyProperties(invDetail, invProductDetailEntity, "id");
if (StrUtil.isNotBlank(invDetail.getProductionDate())) {
invProductDetailEntity.setProductDate(invDetail.getProductionDate());
}
invProductDetailEntity.setProductIdFk(invDetail.getProductIdFk());
invProductDetailEntity.setInvProductIdFk(invProductEntity.getId());
invProductDetailDao.insert(invProductDetailEntity);
log.info("插入库存详情数据");
});
}
}
});
}
return "success";
} catch (Exception e) {
log.error("复制数据失败", e);
}
return "error";
}
}

@ -1,35 +0,0 @@
package com.glxp.udi.admin.mongo;
public class MongoDBName {
/**
*
*/
public static final String NAME_ORDER = "io_order";
/**
*
*/
public static final String NAME_ORDER_DETAIL = "io_order_detail";
/**
*
*/
public static final String NAME_CODE_TEMP = "io_code_temp";
/**
*
*/
public static final String NAME_CODE = "io_code";
/**
*
*/
public static final String NAME_INV_PRODUCT = "io_inv_product";
/**
*
*/
public static final String NAME_INV_PRODUCT_DETAIL = "io_inv_product_detail";
}

@ -1,150 +0,0 @@
package com.glxp.udi.admin.mongo.dao;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.glxp.udi.admin.entity.inout.WarehouseEntity;
import com.glxp.udi.admin.entity.mongo.WarehouseMdEntity;
import com.glxp.udi.admin.mongo.MongoDBName;
import com.glxp.udi.admin.mongo.dao.base.MongoBaseDao;
import com.glxp.udi.admin.mongo.utils.MongoPageHelper;
import com.glxp.udi.admin.mongo.utils.PageResult;
import com.glxp.udi.admin.req.inout.FilterWarehouseRequest;
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.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
@Component
public class CodesMdDao implements MongoBaseDao<WarehouseEntity, FilterWarehouseRequest> {
@Resource
private MongoTemplate mongoTemplate;
@Resource
private MongoPageHelper mongoPageHelper;
@Override
public PageResult<WarehouseEntity> pageQuery(Query query, FilterWarehouseRequest filterWarehouseRequest, int page, int size) {
if (null == query && null != filterWarehouseRequest) {
query = buildQuery(filterWarehouseRequest);
}
return mongoPageHelper.pageQuery(query, WarehouseEntity.class, size, page, MongoDBName.NAME_CODE);
}
@Override
public List<WarehouseEntity> findList(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query && null != filterWarehouseRequest) {
query = buildQuery(filterWarehouseRequest);
}
return mongoTemplate.find(query, WarehouseEntity.class, MongoDBName.NAME_CODE);
}
@Override
public WarehouseEntity findOne(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query && null != filterWarehouseRequest) {
query = buildQuery(filterWarehouseRequest);
}
return mongoTemplate.findOne(query, WarehouseEntity.class, MongoDBName.NAME_CODE);
}
@Override
public void update(Query query, Update update, WarehouseEntity warehouseEntity) {
if (null == query) {
query = buildQuery(warehouseEntity);
}
if (null == update) {
update = buildUpdate(warehouseEntity);
}
mongoTemplate.updateMulti(query, update, WarehouseEntity.class, MongoDBName.NAME_CODE);
}
@Override
public void delete(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query) {
query = buildQuery(filterWarehouseRequest);
}
mongoTemplate.remove(query, WarehouseEntity.class, MongoDBName.NAME_CODE);
}
@Override
public long count(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query) {
query = buildQuery(filterWarehouseRequest);
}
return mongoTemplate.count(query, WarehouseEntity.class, MongoDBName.NAME_CODE);
}
@Override
public void insert(WarehouseEntity warehouseEntity) {
mongoTemplate.insert(warehouseEntity, MongoDBName.NAME_CODE);
}
@Override
public void insert(List<WarehouseEntity> records) {
mongoTemplate.insert(records, MongoDBName.NAME_CODE);
}
/**
* mongodb
*
* @param filterWarehouseRequest
* @return
*/
private Query buildQuery(FilterWarehouseRequest filterWarehouseRequest) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(FilterWarehouseRequest.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(filterWarehouseRequest, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
});
return query;
}
/**
* mongodb
*
* @param warehouseEntity
* @return
*/
private Query buildQuery(WarehouseEntity warehouseEntity) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(WarehouseEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(warehouseEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
});
return query;
}
/**
* mongodb
*
* @param warehouseEntity
* @return
*/
private Update buildUpdate(WarehouseEntity warehouseEntity) {
Update update = new Update();
Field[] fields = ReflectUtil.getFields(WarehouseEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(warehouseEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
update.set(field.getName(), fieldValue);
}
});
return update;
}
public List<WarehouseMdEntity> getCodesList() {
return mongoTemplate.findAll(WarehouseMdEntity.class, MongoDBName.NAME_CODE);
}
}

@ -1,149 +0,0 @@
package com.glxp.udi.admin.mongo.dao;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.glxp.udi.admin.entity.inout.WarehousetempEntity;
import com.glxp.udi.admin.entity.mongo.WarehousetempMdEntity;
import com.glxp.udi.admin.mongo.MongoDBName;
import com.glxp.udi.admin.mongo.dao.base.MongoBaseDao;
import com.glxp.udi.admin.mongo.utils.MongoPageHelper;
import com.glxp.udi.admin.mongo.utils.PageResult;
import com.glxp.udi.admin.req.inout.FilterWarehouseRequest;
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.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
@Component
public class CodesTempMdDao implements MongoBaseDao<WarehousetempEntity, FilterWarehouseRequest> {
@Resource
private MongoTemplate mongoTemplate;
@Resource
private MongoPageHelper mongoPageHelper;
public PageResult<WarehousetempEntity> pageQuery(Query query, FilterWarehouseRequest filterWarehouseRequest, int page, int size) {
if (null == query && null != filterWarehouseRequest) {
query = buildQuery(filterWarehouseRequest);
}
return mongoPageHelper.pageQuery(query, WarehousetempEntity.class, size, page, MongoDBName.NAME_CODE_TEMP);
}
@Override
public List<WarehousetempEntity> findList(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query && null != filterWarehouseRequest) {
query = buildQuery(filterWarehouseRequest);
}
return mongoTemplate.find(query, WarehousetempEntity.class, MongoDBName.NAME_CODE_TEMP);
}
@Override
public WarehousetempEntity findOne(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query && null != filterWarehouseRequest) {
query = buildQuery(filterWarehouseRequest);
}
return mongoTemplate.findOne(query, WarehousetempEntity.class, MongoDBName.NAME_CODE_TEMP);
}
@Override
public void update(Query query, Update update, WarehousetempEntity WarehousetempEntity) {
if (null == query) {
query = buildQuery(WarehousetempEntity);
}
if (null == update) {
update = buildUpdate(WarehousetempEntity);
}
mongoTemplate.updateMulti(query, update, WarehousetempEntity.class, MongoDBName.NAME_CODE_TEMP);
}
@Override
public void delete(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query) {
query = buildQuery(filterWarehouseRequest);
}
mongoTemplate.remove(query, WarehousetempEntity.class, MongoDBName.NAME_CODE_TEMP);
}
@Override
public long count(Query query, FilterWarehouseRequest filterWarehouseRequest) {
if (null == query) {
query = buildQuery(filterWarehouseRequest);
}
return mongoTemplate.count(query, WarehousetempEntity.class, MongoDBName.NAME_CODE_TEMP);
}
@Override
public void insert(WarehousetempEntity WarehousetempEntity) {
mongoTemplate.insert(WarehousetempEntity, MongoDBName.NAME_CODE_TEMP);
}
@Override
public void insert(List<WarehousetempEntity> records) {
mongoTemplate.insert(records, MongoDBName.NAME_CODE_TEMP);
}
/**
* mongodb
*
* @param filterWarehouseRequest
* @return
*/
private Query buildQuery(FilterWarehouseRequest filterWarehouseRequest) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(FilterWarehouseRequest.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(filterWarehouseRequest, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
});
return query;
}
/**
* mongodb
*
* @param warehousetempEntity
* @return
*/
private Query buildQuery(WarehousetempEntity warehousetempEntity) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(WarehousetempEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(warehousetempEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
});
return query;
}
/**
* mongodb
*
* @param warehousetempEntity
* @return
*/
private Update buildUpdate(WarehousetempEntity warehousetempEntity) {
Update update = new Update();
Field[] fields = ReflectUtil.getFields(WarehousetempEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(warehousetempEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
update.set(field.getName(), fieldValue);
}
});
return update;
}
public List<WarehousetempMdEntity> getCodesTempList() {
return mongoTemplate.findAll(WarehousetempMdEntity.class, MongoDBName.NAME_CODE_TEMP);
}
}

@ -1,162 +0,0 @@
package com.glxp.udi.admin.mongo.dao;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.glxp.udi.admin.entity.inout.InvProductDetailEntity;
import com.glxp.udi.admin.entity.mongo.InvProductDetailMdEntity;
import com.glxp.udi.admin.mongo.MongoDBName;
import com.glxp.udi.admin.mongo.dao.base.MongoBaseDao;
import com.glxp.udi.admin.mongo.utils.MongoPageHelper;
import com.glxp.udi.admin.mongo.utils.PageResult;
import com.glxp.udi.admin.req.inout.FilterInvProductDetailRequest;
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.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
@Component
public class InvProductDetailMdDao implements MongoBaseDao<InvProductDetailEntity, FilterInvProductDetailRequest> {
@Resource
private MongoTemplate mongoTemplate;
@Resource
private MongoPageHelper mongoPageHelper;
@Override
public PageResult<InvProductDetailEntity> pageQuery(Query query, FilterInvProductDetailRequest filterInvProductDetailRequest, int page, int size) {
if (null == query && null != filterInvProductDetailRequest) {
query = buildQuery(filterInvProductDetailRequest);
}
return mongoPageHelper.pageQuery(query, InvProductDetailEntity.class, size, page, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public List<InvProductDetailEntity> findList(Query query, FilterInvProductDetailRequest filterInvProductDetailRequest) {
if (null == query && null != filterInvProductDetailRequest) {
query = buildQuery(filterInvProductDetailRequest);
}
return mongoTemplate.find(query, InvProductDetailEntity.class, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public InvProductDetailEntity findOne(Query query, FilterInvProductDetailRequest filterInvProductDetailRequest) {
if (null == query && null != filterInvProductDetailRequest) {
query = buildQuery(filterInvProductDetailRequest);
}
return mongoTemplate.findOne(query, InvProductDetailEntity.class, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public void update(Query query, Update update, InvProductDetailEntity invProductDetailEntity) {
if (null == query) {
query = buildQuery(invProductDetailEntity);
}
if (null == update) {
update = buildUpdate(invProductDetailEntity);
}
mongoTemplate.updateMulti(query, update, InvProductDetailEntity.class, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public void delete(Query query, FilterInvProductDetailRequest filterInvProductDetailRequest) {
if (null == query && null != filterInvProductDetailRequest) {
buildQuery(filterInvProductDetailRequest);
}
mongoTemplate.remove(query, InvProductDetailEntity.class, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public long count(Query query, FilterInvProductDetailRequest filterInvProductDetailRequest) {
if (null == query && null != filterInvProductDetailRequest) {
buildQuery(filterInvProductDetailRequest);
}
return mongoTemplate.count(query, InvProductDetailEntity.class, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public void insert(InvProductDetailEntity invProductDetailEntity) {
mongoTemplate.insert(invProductDetailEntity, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
@Override
public void insert(List<InvProductDetailEntity> records) {
mongoTemplate.insert(records, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
/**
* mongodb
*
* @param filterInvProductDetailRequest
* @return
*/
private Query buildQuery(FilterInvProductDetailRequest filterInvProductDetailRequest) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(FilterInvProductDetailRequest.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(filterInvProductDetailRequest, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if ("invCodes".equals(field.getName())) {
query.addCriteria(Criteria.where("locStorageCode").in(fieldValue));
} else {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
}
});
return query;
}
/**
* mongodb
*
* @param invProductDetailEntity
* @return
*/
private Query buildQuery(InvProductDetailEntity invProductDetailEntity) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(InvProductDetailEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(invProductDetailEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if ("id".equals(field.getName())) {
query.addCriteria(Criteria.where("_id").is(fieldValue));
} else {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
}
});
return query;
}
/**
* mongodb
*
* @param invProductDetailEntity
* @return
*/
private Update buildUpdate(InvProductDetailEntity invProductDetailEntity) {
Update update = new Update();
Field[] fields = ReflectUtil.getFields(InvProductDetailEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(invProductDetailEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if (!"id".equals(field.getName())) {
update.set(field.getName(), fieldValue);
}
}
});
return update;
}
public List<InvProductDetailMdEntity> getInvDetailList(String invProductId) {
Query query = new Query();
query.addCriteria(Criteria.where("invProductIdFk").is(invProductId));
return mongoTemplate.find(query, InvProductDetailMdEntity.class, MongoDBName.NAME_INV_PRODUCT_DETAIL);
}
}

@ -1,187 +0,0 @@
package com.glxp.udi.admin.mongo.dao;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.glxp.udi.admin.entity.inout.InvProductEntity;
import com.glxp.udi.admin.entity.mongo.InvProductMdEntity;
import com.glxp.udi.admin.mongo.MongoDBName;
import com.glxp.udi.admin.mongo.dao.base.MongoBaseDao;
import com.glxp.udi.admin.mongo.utils.MongoPageHelper;
import com.glxp.udi.admin.mongo.utils.PageResult;
import com.glxp.udi.admin.req.inventory.FilterInvProductRequest;
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.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
@Component
public class InvProductMdDao implements MongoBaseDao<InvProductEntity, FilterInvProductRequest> {
@Resource
private MongoTemplate mongoTemplate;
@Resource
private MongoPageHelper mongoPageHelper;
@Override
public PageResult<InvProductEntity> pageQuery(Query query, FilterInvProductRequest filterInvProductRequest, int page, int size) {
if (null == query && null != filterInvProductRequest) {
query = buildQuery(filterInvProductRequest);
}
return mongoPageHelper.pageQuery(query, InvProductEntity.class, size, page, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public List<InvProductEntity> findList(Query query, FilterInvProductRequest filterInvProductRequest) {
if (null == query && null != filterInvProductRequest) {
query = buildQuery(filterInvProductRequest);
}
return mongoTemplate.find(query, InvProductEntity.class, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public InvProductEntity findOne(Query query, FilterInvProductRequest filterInvProductRequest) {
if (null == query && null != filterInvProductRequest) {
query = buildQuery(filterInvProductRequest);
}
return mongoTemplate.findOne(query, InvProductEntity.class, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public void update(Query query, Update update, InvProductEntity invProductEntity) {
if (null == query) {
query = buildQuery(invProductEntity);
}
if (null == update) {
update = buildUpdate(invProductEntity);
}
mongoTemplate.updateMulti(query, update, InvProductEntity.class, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public void delete(Query query, FilterInvProductRequest filterInvProductRequest) {
if (null == query && null != filterInvProductRequest) {
query = buildQuery(filterInvProductRequest);
}
mongoTemplate.remove(query, InvProductEntity.class, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public long count(Query query, FilterInvProductRequest filterInvProductRequest) {
if (null == query && null != filterInvProductRequest) {
query = buildQuery(filterInvProductRequest);
}
return mongoTemplate.count(query, InvProductEntity.class, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public void insert(InvProductEntity invProductEntity) {
mongoTemplate.insert(invProductEntity, MongoDBName.NAME_INV_PRODUCT);
}
@Override
public void insert(List<InvProductEntity> records) {
mongoTemplate.insert(records, MongoDBName.NAME_INV_PRODUCT);
}
/**
* mongodb
*
* @param filterInvProductRequest
* @return
*/
private Query buildQuery(FilterInvProductRequest filterInvProductRequest) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(FilterInvProductRequest.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(filterInvProductRequest, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
switch (field.getName()) {
case "uuids":
query.addCriteria(Criteria.where("relIdFk").in(fieldValue));
break;
case "invCodes":
query.addCriteria(Criteria.where("locStorageCode").in(fieldValue));
break;
case "cpmctymc": {
Pattern pattern = Pattern.compile("^.*" + fieldValue + ".*$");
query.addCriteria(Criteria.where("productsName").regex(pattern));
break;
}
case "zczbhhzbapzbh": {
Pattern pattern = Pattern.compile("^.*" + fieldValue + ".*$");
query.addCriteria(Criteria.where("zczbhhzbapzbh").regex(pattern));
break;
}
case "manufactory": {
Pattern pattern = Pattern.compile("^.*" + fieldValue + ".*$");
query.addCriteria(Criteria.where("manufactory").regex(pattern));
break;
}
case "ggxh": {
Pattern pattern = Pattern.compile("^.*" + fieldValue + ".*$");
query.addCriteria(Criteria.where("ggxh").regex(pattern));
break;
}
default:
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
break;
}
}
});
return query;
}
/**
* mongodb
*
* @param invProductEntity
* @return
*/
private Query buildQuery(InvProductEntity invProductEntity) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(InvProductEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(invProductEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if ("id".equals(field.getName())) {
query.addCriteria(Criteria.where("_id").is(fieldValue));
} else {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
}
});
return query;
}
/**
* mongodb
*
* @param invProductEntity
* @return
*/
private Update buildUpdate(InvProductEntity invProductEntity) {
Update update = new Update();
Field[] fields = ReflectUtil.getFields(InvProductEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(invProductEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if (!"id".equals(field.getName())) {
update.set(field.getName(), fieldValue);
}
}
});
return update;
}
public List<InvProductMdEntity> getInvList() {
return mongoTemplate.findAll(InvProductMdEntity.class, MongoDBName.NAME_INV_PRODUCT);
}
}

@ -1,162 +0,0 @@
package com.glxp.udi.admin.mongo.dao;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.glxp.udi.admin.entity.inout.OrderDetailEntity;
import com.glxp.udi.admin.entity.mongo.ErpOrderEntity;
import com.glxp.udi.admin.mongo.MongoDBName;
import com.glxp.udi.admin.mongo.dao.base.MongoBaseDao;
import com.glxp.udi.admin.mongo.utils.MongoPageHelper;
import com.glxp.udi.admin.mongo.utils.PageResult;
import com.glxp.udi.admin.req.inout.FilterOrderDetailRequest;
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.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
@Component
public class OrderDetailMdDao implements MongoBaseDao<OrderDetailEntity, FilterOrderDetailRequest> {
@Resource
private MongoTemplate mongoTemplate;
@Resource
private MongoPageHelper mongoPageHelper;
@Override
public PageResult<OrderDetailEntity> pageQuery(Query query, FilterOrderDetailRequest filterOrderDetailRequest, int page, int size) {
if (null == query && null != filterOrderDetailRequest) {
query = buildQuery(filterOrderDetailRequest);
}
return mongoPageHelper.pageQuery(query, OrderDetailEntity.class, size, page, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public List<OrderDetailEntity> findList(Query query, FilterOrderDetailRequest filterOrderDetailRequest) {
if (null == query && null != filterOrderDetailRequest) {
query = buildQuery(filterOrderDetailRequest);
}
return mongoTemplate.find(query, OrderDetailEntity.class, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public OrderDetailEntity findOne(Query query, FilterOrderDetailRequest filterOrderDetailRequest) {
if (null == query && null != filterOrderDetailRequest) {
query = buildQuery(filterOrderDetailRequest);
}
return mongoTemplate.findOne(query, OrderDetailEntity.class, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public void update(Query query, Update update, OrderDetailEntity orderDetailEntity) {
if (null == query) {
query = buildQuery(orderDetailEntity);
}
if (null == update) {
update = buildUpdate(orderDetailEntity);
}
mongoTemplate.updateMulti(query, update, OrderDetailEntity.class, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public void delete(Query query, FilterOrderDetailRequest filterOrderDetailRequest) {
if (null == query) {
query = buildQuery(filterOrderDetailRequest);
}
mongoTemplate.remove(query, OrderDetailEntity.class, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public long count(Query query, FilterOrderDetailRequest filterOrderDetailRequest) {
if (null == query) {
query = buildQuery(filterOrderDetailRequest);
}
return mongoTemplate.count(query, OrderDetailEntity.class, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public void insert(OrderDetailEntity orderDetailEntity) {
mongoTemplate.insert(orderDetailEntity, MongoDBName.NAME_ORDER_DETAIL);
}
@Override
public void insert(List<OrderDetailEntity> records) {
mongoTemplate.insert(records, MongoDBName.NAME_ORDER_DETAIL);
}
/**
* mongodb
*
* @param filterOrderDetailRequest
* @return
*/
private Query buildQuery(FilterOrderDetailRequest filterOrderDetailRequest) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(FilterOrderDetailRequest.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(filterOrderDetailRequest, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if ("orderId".equals(field.getName())) {
query.addCriteria(Criteria.where("orderIdFk").is(fieldValue));
} else {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
}
});
return query;
}
/**
* mongodb
*
* @param orderDetailEntity
* @return
*/
private Query buildQuery(OrderDetailEntity orderDetailEntity) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(OrderDetailEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(orderDetailEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if ("orderId".equals(field.getName())) {
query.addCriteria(Criteria.where("orderIdFk").is(fieldValue));
} else {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
}
});
return query;
}
/**
*
*
* @param orderDetailEntity
* @return
*/
private Update buildUpdate(OrderDetailEntity orderDetailEntity) {
Update update = new Update();
Field[] fields = ReflectUtil.getFields(OrderDetailEntity.class);
Arrays.stream(fields).forEach(field -> {
Object fieldValue = ReflectUtil.getFieldValue(orderDetailEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue)) {
if (!"orderId".equals(field.getName()) && !"orderIdFk".equals(field.getName())) {
update.set(field.getName(), fieldValue);
}
}
});
return update;
}
public List<ErpOrderEntity> getOrderDetailList() {
return mongoTemplate.findAll(ErpOrderEntity.class, MongoDBName.NAME_ORDER_DETAIL);
}
}

@ -1,186 +0,0 @@
package com.glxp.udi.admin.mongo.dao;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import com.glxp.udi.admin.entity.mongo.OrderMdEntity;
import com.glxp.udi.admin.mongo.MongoDBName;
import com.glxp.udi.admin.mongo.dao.base.MongoBaseDao;
import com.glxp.udi.admin.mongo.utils.MongoPageHelper;
import com.glxp.udi.admin.mongo.utils.PageResult;
import com.glxp.udi.admin.req.inout.OrderFilterRequest;
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.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.List;
/**
*
*/
@Component
public class OrderMdDao implements MongoBaseDao<OrderMdEntity, OrderFilterRequest> {
@Resource
private MongoTemplate mongoTemplate;
@Resource
private MongoPageHelper mongoPageHelper;
@Override
public PageResult<OrderMdEntity> pageQuery(Query query, OrderFilterRequest orderFilterRequest, int page, int size) {
if (null == query && orderFilterRequest != null) {
query = buildQuery(orderFilterRequest);
}
return mongoPageHelper.pageQuery(query, OrderMdEntity.class, size, page, MongoDBName.NAME_ORDER);
}
@Override
public List<OrderMdEntity> findList(Query query, OrderFilterRequest orderFilterRequest) {
if (null == query && null != orderFilterRequest) {
query = buildQuery(orderFilterRequest);
}
return mongoTemplate.find(query, OrderMdEntity.class, MongoDBName.NAME_ORDER);
}
@Override
public OrderMdEntity findOne(Query query, OrderFilterRequest orderFilterRequest) {
if (query == null && null != orderFilterRequest) {
query = buildQuery(orderFilterRequest);
}
return mongoTemplate.findOne(query, OrderMdEntity.class, MongoDBName.NAME_ORDER);
}
@Override
public void update(Query query, Update update, OrderMdEntity orderMdEntity) {
if (null == query) {
query = buildQuery(orderMdEntity);
}
if (null == update) {
update = buildUpdate(orderMdEntity);
}
mongoTemplate.updateMulti(query, update, OrderMdEntity.class, MongoDBName.NAME_ORDER);
}
@Override
public void delete(Query query, OrderFilterRequest orderFilterRequest) {
if (null == query && null != orderFilterRequest) {
query = buildQuery(orderFilterRequest);
}
mongoTemplate.remove(query, OrderMdEntity.class, MongoDBName.NAME_ORDER);
}
@Override
public long count(Query query, OrderFilterRequest orderFilterRequest) {
if (null == query && null != orderFilterRequest) {
query = buildQuery(orderFilterRequest);
}
return mongoTemplate.count(query, OrderMdEntity.class, MongoDBName.NAME_ORDER);
}
@Override
public void insert(OrderMdEntity orderMdEntity) {
mongoTemplate.insert(orderMdEntity, MongoDBName.NAME_ORDER);
}
@Override
public void insert(List<OrderMdEntity> records) {
mongoTemplate.insert(records, MongoDBName.NAME_ORDER);
}
/**
* mongodb
*
* @param orderFilterRequest
* @return
*/
private Query buildQuery(OrderFilterRequest orderFilterRequest) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(OrderFilterRequest.class);
for (Field field : fields) {
if (field.getName() != "page" && field.getName() != "limit") {
Object fieldValue = ReflectUtil.getFieldValue(orderFilterRequest, field);
if (ObjectUtil.isNotEmpty(fieldValue) && StrUtil.isNotBlank(String.valueOf(fieldValue))) {
if ("id".equals(field.getName())) {
query.addCriteria(Criteria.where("orderId").is(fieldValue));
} else if ("invCodes".equals(field.getName())) {
List invCodes = (List) fieldValue;
query.addCriteria(Criteria.where("locStorageCode").in(invCodes.toArray()));
} else if ("actDate".equals(field.getName())) {
query.addCriteria(Criteria.where("actDate").gte(fieldValue + " 00:00:00").andOperator(Criteria.where("actDate").lte(fieldValue + " 23:59:59")));
} else if ("isError".equals(field.getName())) {
query.addCriteria(Criteria.where("status").ne(fieldValue));
} else if ("receiveStatus".equals(field.getName())) {
break;
} else if ("checkReceiveStatus".equals(field.getName())) {
if ("true".equals(String.valueOf(fieldValue))) {
Object receiveStatus = ReflectUtil.getFieldValue(orderFilterRequest, "receiveStatus");
if (null != receiveStatus) {
query.addCriteria(Criteria.where("receiveStatus").is(fieldValue));
} else {
query.addCriteria(Criteria.where("receiveStatus").ne(0));
}
}
} else {
query.addCriteria(Criteria.where(field.getName()).is(fieldValue));
}
} else {
if ("action".equals(field.getName())) {
query.addCriteria(Criteria.where("action").ne("StockCheck"));
}
}
}
}
return query;
}
/**
* mongodb
*
* @param orderMdEntity
* @return
*/
private Query buildQuery(OrderMdEntity orderMdEntity) {
Query query = new Query();
Field[] fields = ReflectUtil.getFields(OrderMdEntity.class);
for (Field field : fields) {
Object fieldValue = ReflectUtil.getFieldValue(orderMdEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue) && StrUtil.isNotBlank(String.valueOf(fieldValue))) {
if ("id".equals(field.getName())) {
query.addCriteria(Criteria.where("_id").is(fieldValue));
}
}
}
return query;
}
/**
* mongodb
*
* @param orderMdEntity
* @return
*/
private Update buildUpdate(OrderMdEntity orderMdEntity) {
Update update = new Update();
Field[] fields = ReflectUtil.getFields(OrderMdEntity.class);
for (Field field : fields) {
Object fieldValue = ReflectUtil.getFieldValue(orderMdEntity, field);
if (ObjectUtil.isNotEmpty(fieldValue) && StrUtil.isNotBlank(String.valueOf(fieldValue))) {
if (!field.getName().equals("id") && !field.getName().equals("orderId")) {
update.set(field.getName(), fieldValue);
}
}
}
return update;
}
public List<OrderMdEntity> getOrderList() {
return mongoTemplate.findAll(OrderMdEntity.class, MongoDBName.NAME_ORDER);
}
}

@ -1,84 +0,0 @@
package com.glxp.udi.admin.mongo.dao.base;
import com.glxp.udi.admin.mongo.utils.PageResult;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import java.util.List;
/**
* mongo
*/
public interface MongoBaseDao<T, Q> {
/**
*
*
* @param query
* @param q
* @param page
* @param size
* @return
*/
PageResult<T> pageQuery(Query query, Q q, int page, int size);
/**
*
*
* @param query
* @param q
* @return
*/
List<T> findList(Query query, Q q);
/**
*
*
* @param query
* @param q
* @return
*/
T findOne(Query query, Q q);
/**
*
*
* @param query
* @param update
* @param t
*/
void update(Query query, Update update, T t);
/**
*
*
* @param query
* @param q
*/
void delete(Query query, Q q);
/**
*
*
* @param query
* @param q
* @return
*/
long count(Query query, Q q);
/**
*
*
* @param t
*/
void insert(T t);
/**
*
*
* @param records
*/
void insert(List<T> records);
}

@ -1,109 +0,0 @@
package com.glxp.udi.admin.mongo.utils;
import org.apache.commons.lang3.StringUtils;
import org.bson.types.ObjectId;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
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.stereotype.Component;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* MongoDBSpring-data使.
*/
@Component
public class MongoPageHelper {
private static final int FIRST_PAGE_NUM = 1;
private static final String ID = "_id";
private final MongoTemplate mongoTemplate;
public MongoPageHelper(MongoTemplate mongoTemplate) {
this.mongoTemplate = mongoTemplate;
}
/**
* .
*
* @see MongoPageHelper#pageQuery(Query,
* Class, Integer, Integer, Function,
* String)
*/
public <T> PageResult<T> pageQuery(Query query, Class<T> entityClass, Integer pageSize,
Integer pageNum, String tableName) {
return pageQuery(query, entityClass, pageSize, pageNum, Function.identity(), null, tableName);
}
/**
* 使skip-limit.
*
* @see MongoPageHelper#pageQuery(Query,
* Class, Integer, Integer, Function,
* String)
*/
public <T, R> PageResult<R> pageQuery(Query query, Class<T> entityClass,
Integer pageSize, Integer pageNum, Function<T, R> mapper, String tableName) {
return pageQuery(query, entityClass, pageSize, pageNum, mapper, null);
}
public <T> PageResult<T> pageQuery(Query query, Class<T> entityClass, Integer pageSize,
Integer pageNum, String lastId, String tableName) {
return pageQuery(query, entityClass, pageSize, pageNum, Function.identity(), null, tableName);
}
/**
* .
*
* @param query Mongo Query.
* @param entityClass Mongo collectionentity class.
* @param mapper dblistentityClass, 使mapper.
* @param pageSize .
* @param pageNum .
* @param lastId , skip-limitfind(_id>lastId).limit.
* ObjectId nullpageNum.
* @param <T> collectionclass.
* @param <R>
* @return PageResultpage.
*/
public <T, R> PageResult<R> pageQuery(Query query, Class<T> entityClass,
Integer pageSize, Integer pageNum, Function<T, R> mapper, String lastId, String tableName) {
//分页逻辑
long total = mongoTemplate.count(query, entityClass, tableName);
final Integer pages = (int) Math.ceil(total / (double) pageSize);
if (pageNum <= 0 || pageNum > pages) {
pageNum = FIRST_PAGE_NUM;
}
final Criteria criteria = new Criteria();
if (StringUtils.isNotBlank(lastId)) {
if (pageNum != FIRST_PAGE_NUM) {
criteria.and(ID).gt(new ObjectId(lastId));
}
query.limit(pageSize);
} else {
int skip = pageSize * (pageNum - 1);
query.skip(skip).limit(pageSize);
}
final List<T> entityList = mongoTemplate
.find(query.addCriteria(criteria)
.with(Sort.by(Collections.singletonList(new Order(Direction.DESC, ID)))),
entityClass, tableName);
final PageResult<R> pageResult = new PageResult<>();
pageResult.setTotal(total);
pageResult.setPages(pages);
pageResult.setPageSize(pageSize);
pageResult.setPageNum(pageNum);
pageResult.setList(entityList.stream().map(mapper).collect(Collectors.toList()));
return pageResult;
}
}

@ -1,41 +0,0 @@
package com.glxp.udi.admin.mongo.utils;
import lombok.Data;
import java.util.List;
/**
* .
*
* @author Ryan
*/
@Data
public class PageResult<T> {
/**
* 1
*/
private Integer pageNum;
/**
*
*/
private Integer pageSize;
/**
*
*/
private Long total;
/**
*
*/
private Integer pages;
/**
*
*/
private List<T> list;
}

@ -4,9 +4,6 @@ spring:
url: jdbc:mysql://127.0.0.1:3306/udims?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
username: root
password: mysql@2020
data:
mongodb:
uri: mongodb://127.0.0.1:27017/udiwms
redis:
database: 4

@ -8,10 +8,6 @@ spring:
username: root
password: root
data:
mongodb:
uri: mongodb://192.168.0.66:27017/udiwms
redis:
database: 3
host: 192.168.0.66

Loading…
Cancel
Save