package jnpf.base.util.dataSet;
|
|
import jnpf.base.ActionResult;
|
import jnpf.base.entity.DictionaryDataEntity;
|
import jnpf.base.model.dataset.DataSetConfig;
|
import jnpf.base.model.dataset.DataSetOptions;
|
import jnpf.base.model.dataset.DataSetSwapModel;
|
import jnpf.base.service.DataInterfaceService;
|
import jnpf.base.service.DictionaryDataService;
|
import jnpf.permission.*;
|
import jnpf.util.*;
|
import jnpf.util.data.DataSourceContextHolder;
|
import jnpf.util.visiual.DataTypeConst;
|
import lombok.Data;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.collections4.MapUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.*;
|
import java.util.concurrent.CountDownLatch;
|
import java.util.stream.Collectors;
|
|
/**
|
* 数据集数据转换多线程
|
*
|
* @author JNPF开发平台组
|
* @version v5.0.0
|
* @copyright 引迈信息技术有限公司
|
* @date 2024/7/15 16:45:09
|
*/
|
@Slf4j
|
@Component
|
public class DataSetExecutor {
|
@Autowired
|
private RedisUtil redisUtil;
|
@Autowired
|
private UserApi userApi;
|
@Autowired
|
private OrganizeApi organizeApi;
|
@Autowired
|
private PositionApi positionApi;
|
@Autowired
|
private RoleApi roleApi;
|
@Autowired
|
private GroupApi groupApi;
|
@Autowired
|
private DictionaryDataService dictionaryDataApi;
|
@Autowired
|
private DataInterfaceService dataInterFaceApi;
|
|
|
private String tenantId = "";
|
private static long DEFAULT_CACHE_TIME = 60 * 5;
|
|
|
/**
|
* 添加多线程
|
*/
|
public void executorRedis(Map<String, Object> localCache, String printId, List<DataSetSwapModel> swapList, Map<String, Object> map) {
|
tenantId = Optional.ofNullable(DataSourceContextHolder.getDatasourceId()).orElse("");
|
Map<String, OateSetExParam> listExecutor = new HashMap<>();
|
if (MapUtils.isNotEmpty(map)) {
|
for (String key : map.keySet()) {
|
if (Objects.isNull(map.get(key))) continue;
|
List<Map<String, Object>> list = (List<Map<String, Object>>) map.get(key);
|
boolean needOrg = false, needDep = false, needPos = false, needUser = false, needRole = false, needGroup = false;
|
for (Map<String, Object> item : list) {
|
for (DataSetSwapModel model : swapList) {
|
String field = model.getField();
|
String type = model.getType();
|
if(StringUtil.isEmpty(field) || StringUtil.isEmpty(type)) continue;
|
String[] fields = field.split("\\.");
|
|
DataSetConfig config = model.getConfig();
|
if (!key.equals(fields[0]) || item.get(fields[1]) == null || "".equals(item.get(fields[1]))) {
|
continue;
|
}
|
String redisKey;
|
switch (type) {
|
case DataSetConstant.KEY_ORG:
|
needOrg = true;
|
break;
|
case DataSetConstant.KEY_DEP:
|
needDep = true;
|
break;
|
case DataSetConstant.KEY_POS:
|
needPos = true;
|
break;
|
case DataSetConstant.KEY_USER:
|
needUser = true;
|
break;
|
case DataSetConstant.KEY_ROLE:
|
needRole = true;
|
break;
|
case DataSetConstant.KEY_GROUP:
|
needGroup = true;
|
break;
|
case DataSetConstant.KEY_USERS:
|
needOrg = true;
|
needDep = true;
|
needPos = true;
|
needUser = true;
|
needRole = true;
|
needGroup = true;
|
break;
|
case DataSetConstant.KEY_SELECT:
|
if (DataTypeConst.STATIC.equals(config.getDataType())) {
|
redisKey = String.format("%s-%s-%s", printId, field, DataTypeConst.STATIC);
|
if (!localCache.containsKey(redisKey)) {
|
listExecutor.putIfAbsent(redisKey, new OateSetExParam(redisKey, DataSetConstant.KEY_SELECT, null, config));
|
}
|
}
|
if (DataTypeConst.DICTIONARY.equals(config.getDataType())) {
|
redisKey = String.format("%s-%s-%s", tenantId, DataTypeConst.DICTIONARY, model.getConfig().getDictionaryType());
|
if (!localCache.containsKey(redisKey)) {
|
listExecutor.putIfAbsent(redisKey, new OateSetExParam(redisKey, DataSetConstant.KEY_SELECT, null, config));
|
}
|
}
|
if (DataTypeConst.DYNAMIC.equals(config.getDataType())) {
|
redisKey = String.format("%s-%s-%s", tenantId, DataTypeConst.DYNAMIC, model.getConfig().getPropsUrl());
|
if (!localCache.containsKey(redisKey)) {
|
listExecutor.putIfAbsent(redisKey, new OateSetExParam(redisKey, DataSetConstant.KEY_SELECT, null, config));
|
}
|
}
|
needGroup = true;
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
//添加系统缓存
|
Map<String, String> reidsKeyMap = new LinkedHashMap<>();
|
if (needOrg) reidsKeyMap.put(tenantId + CacheKeyUtil.SYS_ORG_Tree, DataSetConstant.KEY_ORG);
|
if (needDep) reidsKeyMap.put(tenantId + CacheKeyUtil.SYS_DEP, DataSetConstant.KEY_DEP);
|
if (needPos) reidsKeyMap.put(tenantId + CacheKeyUtil.SYS_POS, DataSetConstant.KEY_POS);
|
if (needUser) reidsKeyMap.put(tenantId + CacheKeyUtil.SYS_USER, DataSetConstant.KEY_USER);
|
if (needRole) reidsKeyMap.put(tenantId + CacheKeyUtil.SYS_ROLE, DataSetConstant.KEY_ROLE);
|
if (needGroup) reidsKeyMap.put(tenantId + CacheKeyUtil.SYS_GROUP, DataSetConstant.KEY_GROUP);
|
for (String redisKey : reidsKeyMap.keySet()) {
|
if (!localCache.containsKey(redisKey)) {
|
listExecutor.putIfAbsent(redisKey, new OateSetExParam(redisKey, reidsKeyMap.get(redisKey), null, null));
|
}
|
}
|
}
|
|
//执行多线程方法
|
if (!listExecutor.isEmpty()) {
|
this.execute(localCache, listExecutor);
|
}
|
}
|
}
|
|
/**
|
* 执行多线程
|
*/
|
private void execute(Map<String, Object> localCache, Map<String, OateSetExParam> listExecutor) {
|
CountDownLatch countDownLatch = new CountDownLatch(listExecutor.size());
|
for (String key : listExecutor.keySet()) {
|
OateSetExParam item = listExecutor.get(key);
|
String redisKey = item.getRedisKey();
|
ThreadPoolExecutorUtil.getExecutor().execute(() -> {
|
try {
|
switch (item.getType()) {
|
case DataSetConstant.KEY_USER:
|
//人员
|
Map<String, Object> userMap;
|
if (redisUtil.exists(redisKey)) {
|
userMap = redisUtil.getMap(redisKey);
|
userMap = Optional.ofNullable(userMap).orElse(new HashMap<>(20));
|
} else {
|
userMap = userApi.getUserMap("id-fullName");
|
if (DataSetSwapUtil.NEEDCACHE_SYS) {
|
redisUtil.insert(redisKey, userMap, DEFAULT_CACHE_TIME);
|
}
|
}
|
localCache.put(CacheKeyUtil.SYS_USER, userMap);
|
break;
|
case DataSetConstant.KEY_ORG:
|
Map<String, Object> orgMap;
|
if (redisUtil.exists(redisKey)) {
|
orgMap = redisUtil.getMap(redisKey);
|
orgMap = Optional.ofNullable(orgMap).orElse(new HashMap<>(20));
|
} else {
|
orgMap = organizeApi.getAllOrgsTreeName();
|
if (DataSetSwapUtil.NEEDCACHE_SYS) {
|
redisUtil.insert(redisKey, orgMap, DEFAULT_CACHE_TIME);
|
}
|
}
|
localCache.put(CacheKeyUtil.SYS_ORG_Tree, orgMap);
|
break;
|
case DataSetConstant.KEY_DEP:
|
Map<String, Object> depMap;
|
if (redisUtil.exists(redisKey)) {
|
depMap = redisUtil.getMap(redisKey);
|
depMap = Optional.ofNullable(depMap).orElse(new HashMap<>(20));
|
} else {
|
depMap = organizeApi.getOrgMap("id-fullName", "");
|
if (DataSetSwapUtil.NEEDCACHE_SYS) {
|
redisUtil.insert(redisKey, depMap, DEFAULT_CACHE_TIME);
|
}
|
}
|
localCache.put(CacheKeyUtil.SYS_DEP, depMap);
|
break;
|
case DataSetConstant.KEY_POS:
|
Map<String, String> posMap;
|
if (redisUtil.exists(redisKey)) {
|
posMap = redisUtil.getMap(redisKey);
|
posMap = Optional.ofNullable(posMap).orElse(new HashMap<>(20));
|
} else {
|
posMap = positionApi.getPosFullNameMap();
|
if (DataSetSwapUtil.NEEDCACHE_SYS) {
|
redisUtil.insert(redisKey, posMap, DEFAULT_CACHE_TIME);
|
}
|
}
|
localCache.put(CacheKeyUtil.SYS_POS, posMap);
|
break;
|
case DataSetConstant.KEY_ROLE:
|
Map<String, Object> roleMap;
|
if (redisUtil.exists(redisKey)) {
|
roleMap = redisUtil.getMap(redisKey);
|
roleMap = Optional.ofNullable(roleMap).orElse(new HashMap<>(20));
|
} else {
|
roleMap = roleApi.getRoleMap("id-fullName");
|
if (DataSetSwapUtil.NEEDCACHE_SYS) {
|
redisUtil.insert(redisKey, roleMap, DEFAULT_CACHE_TIME);
|
}
|
}
|
localCache.put(CacheKeyUtil.SYS_ROLE, roleMap);
|
break;
|
case DataSetConstant.KEY_GROUP:
|
Map<String, Object> groupMap;
|
if (redisUtil.exists(redisKey)) {
|
groupMap = redisUtil.getMap(redisKey);
|
groupMap = Optional.ofNullable(groupMap).orElse(new HashMap<>(20));
|
} else {
|
groupMap = groupApi.getGroupMap("id-fullName");
|
if (DataSetSwapUtil.NEEDCACHE_SYS) {
|
redisUtil.insert(redisKey, groupMap, DEFAULT_CACHE_TIME);
|
}
|
}
|
localCache.put(CacheKeyUtil.SYS_GROUP, groupMap);
|
break;
|
|
case DataSetConstant.KEY_SELECT:
|
DataSetConfig config = (DataSetConfig) item.getParam();
|
Map<String, String> selectMap = new HashMap<>(16);
|
List<Map<String, Object>> options = new ArrayList<>();
|
//静态数据
|
if (DataTypeConst.STATIC.equals(config.getDataType())) {
|
if (!localCache.containsKey(redisKey)) {
|
if (!redisUtil.exists(redisKey)) {
|
if (config.getOptions() != null) {
|
List<DataSetOptions> configOptions = config.getOptions();
|
for (DataSetOptions dso : configOptions) {
|
selectMap.put(dso.getId(), dso.getFullName());
|
}
|
}
|
redisUtil.insert(redisKey, selectMap, DEFAULT_CACHE_TIME);
|
localCache.put(redisKey, selectMap);
|
} else {
|
localCache.put(redisKey, redisUtil.getMap(redisKey));
|
}
|
}
|
}
|
|
//数据字典
|
if (DataTypeConst.DICTIONARY.equals(config.getDataType())) {
|
if (!localCache.containsKey(redisKey)) {
|
if (!redisUtil.exists(redisKey)) {
|
List<DictionaryDataEntity> list = dictionaryDataApi.getDicList(config.getDictionaryType());
|
options = list.stream().map(dic -> {
|
Map<String, Object> dictionaryMap = new HashMap<>(16);
|
dictionaryMap.put("id", dic.getId());
|
dictionaryMap.put("enCode", dic.getEnCode());
|
dictionaryMap.put("fullName", dic.getFullName());
|
return dictionaryMap;
|
}).collect(Collectors.toList());
|
String dictionaryData = JsonUtil.getObjectToString(options);
|
redisUtil.insert(redisKey, dictionaryData, DEFAULT_CACHE_TIME);
|
localCache.put(redisKey, options);
|
} else {
|
String dictionaryStringData = redisUtil.getString(redisKey).toString();
|
localCache.put(redisKey, JsonUtil.getJsonToListMap(dictionaryStringData));
|
}
|
}
|
}
|
|
//数据接口
|
if (DataTypeConst.DYNAMIC.equals(config.getDataType())) {
|
if (!localCache.containsKey(redisKey)) {
|
if (!redisUtil.exists(redisKey)) {
|
List<Map<String,Object>> dataList = new ArrayList<>();
|
ActionResult data = dataInterFaceApi.infoToId(config.getPropsUrl(), null, null);
|
if (data != null && data.getData() != null) {
|
if (data.getData() instanceof List) {
|
dataList = (List<Map<String, Object>>) data.getData();
|
}
|
}
|
String dynamicData = JsonUtil.getObjectToString(dataList);
|
redisUtil.insert(redisKey, dynamicData, DEFAULT_CACHE_TIME);
|
localCache.put(redisKey, dataList);
|
} else {
|
String dynamicDataStringData = redisUtil.getString(redisKey).toString();
|
localCache.put(redisKey, JsonUtil.getJsonToListMap(dynamicDataStringData));
|
}
|
}
|
}
|
break;
|
default:
|
|
break;
|
}
|
} catch (Exception e) {
|
log.error("线程执行错误：" + e.getMessage());
|
// e.printStackTrace();
|
} finally {
|
//每执行一次数值减少一
|
countDownLatch.countDown();
|
//也可以给await()设置超时时间，如果超过300s（也可以是时，分）则不再等待，直接执行下面代码。
|
//countDownLatch.await(300,TimeUnit.SECONDS);
|
}
|
});
|
}
|
|
try {
|
//等待计数器归零
|
countDownLatch.await();
|
} catch (InterruptedException e) {
|
log.error("线程计数错误：" + e.getMessage());
|
// e.printStackTrace();
|
}
|
}
|
}
|
|
@Data
|
class OateSetExParam {
|
private String redisKey;
|
private String type;
|
private String interfaceId;
|
private Object param;
|
|
public OateSetExParam(String redisKey, String type, String interfaceId, Object param) {
|
this.redisKey = redisKey;
|
this.type = type;
|
this.interfaceId = interfaceId;
|
this.param = param;
|
}
|
}
|
