package com.iplatform.base.cache;
|
|
import com.iplatform.base.Constants;
|
import com.iplatform.base.service.CodeServiceImpl;
|
import com.iplatform.model.po.S_dict_data;
|
import com.iplatform.model.po.S_dict_type;
|
import com.walker.cache.tree.AbstractCacheTreeProvider;
|
import com.walker.cache.tree.CacheTreeNode;
|
import com.walker.cache.tree.DefaultCacheTreeNode;
|
import com.walker.infrastructure.utils.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
/**
|
* 数据字典缓存定义，该缓存因为树结构复杂，并没有提供'Redis'方式实现。<br>
|
* 不过一般字典数据变动很小，因此在集群环境中也是相对安全。<p></p>
|
* 1) 注意：如果生产环境字典变动较大，而且是集群环境则必须实现'Redis'集中存储缓存对象。
|
* @author 时克英
|
* @date 2023-03-10
|
*/
|
public class DictCacheProvider extends AbstractCacheTreeProvider<S_dict_data> {
|
|
private final SortComparator sort = new SortComparator();
|
private final NodeComparator nodeSort = new NodeComparator();
|
|
// 2023-04-15 添加字典类型与id映射记录，因为
|
private final Map<String, String> dictTypeIdMap = new HashMap<>();
|
|
/**
|
* 根据字典类型，找出对应id，因为前端若依框架中，需要传类型，但系统使用id查询。
|
* @param dictType
|
* @return
|
* @date 2023-04-15
|
*/
|
public String getDictTypeId(String dictType){
|
String id = this.dictTypeIdMap.get(dictType);
|
if(id == null){
|
throw new IllegalArgumentException("根据字典类型，未找到id：" + dictType);
|
}
|
return id;
|
}
|
|
/**
|
* 返回代码集合对象，通常在数据库中可能会存储多个代码ID，可以通过此 方法获取代码集合。
|
* @param codeIds 输入多个代码ID数组
|
* @return
|
*/
|
public List<CacheTreeNode> getCodeList(String[] codeIds){
|
List<CacheTreeNode> result = new ArrayList<CacheTreeNode>(2*2);
|
if(codeIds != null && codeIds.length > 0){
|
for(String cid : codeIds){
|
result.add(this.get(cid));
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 返回给定代码表的子代码项，树结构
|
* @param codeTableName 代码表ID
|
* @return
|
*/
|
public List<CacheTreeNode> getCodeChildrenList(String codeTableName){
|
CacheTreeNode node = this.getOneRootNode(codeTableName);
|
if(node == null){
|
throw new IllegalArgumentException("not found node: " + codeTableName);
|
}
|
Collection<CacheTreeNode> list = node.getChildren();
|
if(list != null){
|
List<CacheTreeNode> result = new ArrayList<CacheTreeNode>();
|
for(CacheTreeNode n : list){
|
result.add(n);
|
}
|
Collections.sort(result, nodeSort);
|
return result;
|
}
|
return null;
|
}
|
|
/**
|
* 返回代码表的下一级子代码集合，返回的是代码对象
|
* @param codeTableName 代码表ID
|
* @return
|
*/
|
public List<S_dict_data> getRootChildrenOneLevelList(String codeTableName){
|
CacheTreeNode node = this.getOneRootNode(codeTableName);
|
// CacheTreeNode node2 =this.getOneRootNode("101");
|
// Object rootCacheNode = null;
|
// for(Iterator<Cachable> it = this.getCache().getIterator(); it.hasNext();){
|
// rootCacheNode = it.next().getValue();
|
// logger.debug("........ {}" + rootCacheNode);
|
// }
|
if(node == null){
|
throw new IllegalArgumentException("not found node: " + codeTableName);
|
}
|
Collection<CacheTreeNode> list = node.getChildren();
|
if(list != null){
|
List<S_dict_data> result = new ArrayList<>();
|
S_dict_data temp = null;
|
for(CacheTreeNode n : list){
|
temp = (S_dict_data)n.getSource();
|
// temp.setChildSum(n.getChildrenSize());
|
result.add(temp);
|
}
|
Collections.sort(result, sort);
|
return result;
|
}
|
return null;
|
}
|
|
/**
|
* 根据某个代码ID，返回其下一级所有子代码集合
|
* @param id
|
* @return
|
*/
|
public List<S_dict_data> getCodeChildrenOneLevelList(String id){
|
CacheTreeNode parent = this.get(id);
|
if(parent == null){
|
return null;
|
}
|
Collection<CacheTreeNode> list = parent.getChildren();
|
if(list != null){
|
List<S_dict_data> result = new ArrayList<>();
|
for(CacheTreeNode n : list){
|
result.add((S_dict_data)n.getSource());
|
}
|
return result;
|
}
|
return null;
|
}
|
|
/**
|
* 返回某个代码下面的所有代码树。
|
* @param id 给定的代码id
|
* @return
|
*/
|
public List<CacheTreeNode> getCodeChildrenTreeList(String id){
|
CacheTreeNode parent = this.get(id);
|
if(parent == null){
|
return null;
|
}
|
Collection<CacheTreeNode> list = parent.getChildren();
|
if(list != null){
|
List<CacheTreeNode> result = new ArrayList<CacheTreeNode>();
|
for(CacheTreeNode n : list){
|
result.add(n);
|
}
|
return result;
|
}
|
return null;
|
}
|
|
// /**
|
// * 搜索代码树，支持多关键字搜索，返回集合数据展示给ztree，注意：返回结果只有一级不再分层
|
// * @param codeTableId 代码表ID
|
// * @param keyLike 查询关键字，如：'锅炉' 或者 '锅炉 电 9号'，多关键词用空格分隔
|
// * @return
|
// */
|
// public String searchLikeTreeNodeList(String codeTableId, String keyLike){
|
//// Collection<CacheTreeNode> deptList = this.getRootList();
|
// Collection<CacheTreeNode> deptList = this.getCodeChildrenList(codeTableId);
|
// JSONArray array = new JSONArray();
|
//
|
// if(deptList != null){
|
// // 过滤某个单位下的根数据集合，后续补充
|
// // ...
|
// String[] keys = StringUtils.stringToArray(keyLike, " ");
|
// boolean multiKeys = false;
|
// if(keys != null && keys.length > 1){
|
// multiKeys = true;
|
// }
|
//
|
// List<CacheTreeNode> tempList = null;
|
// for(CacheTreeNode node : deptList){
|
// // 不是给定单位的数据不要
|
//// if(((TypeTree)node.getSource()).getDept() != dept){
|
//// continue;
|
//// }
|
// if(multiKeys){
|
// logger.debug("------------------");
|
// tempList = node.searchLike(keys);
|
// } else {
|
// tempList = node.searchLike(keyLike);
|
// }
|
// if(!StringUtils.isEmptyList(tempList)){
|
// for(CacheTreeNode c : tempList){
|
// array.add(CodeUtils.createJsonTree(c.getKey(), c.getText()
|
// , Constants.DEFAULT_TREE_ROOT_ID, false, true, CodeUtils.DEFAULT_SEARCH_ICON, false));
|
// }
|
// }
|
// }
|
// }
|
// return array.toString();
|
// }
|
|
@Override
|
protected Map<String, CacheTreeNode> loadRootList() {
|
List<S_dict_type> rootList = this.codeService.queryRootCodeList();
|
if(StringUtils.isEmptyList(rootList)){
|
return null;
|
}
|
// 需要转成'S_dict_data'统一对象，老系统中代码表是一个表，这里是两个表。2023-03-10
|
List<S_dict_data> dictList = new ArrayList<>();
|
S_dict_data data = null;
|
for(S_dict_type type : rootList){
|
data = new S_dict_data();
|
data.setDict_code(type.getDict_id());
|
data.setDict_label(type.getDict_name());
|
data.setParent_id(0L); // 根节点不存在父id，默认；0
|
dictList.add(data);
|
//
|
this.dictTypeIdMap.put(type.getDict_type(), String.valueOf(type.getDict_id()));
|
}
|
return obtainMap(dictList);
|
}
|
|
@Override
|
protected Map<String, CacheTreeNode> loadChildList() {
|
List<S_dict_data> list = this.codeService.queryAllCodeItemList();
|
return obtainMap(list);
|
}
|
|
@Override
|
protected CacheTreeNode toCacheTreeNode(S_dict_data entity) {
|
return new DefaultCacheTreeNode(entity.getDict_code().toString()
|
, entity.getDict_label(), entity, entity.getParent_id().toString());
|
}
|
|
@Override
|
public String getProviderName() {
|
return Constants.CACHE_NAME_DICT;
|
}
|
|
@Override
|
public Class<?> getProviderType() {
|
return S_dict_data.class;
|
}
|
|
private Map<String, CacheTreeNode> obtainMap(List<S_dict_data> list){
|
if(list != null && list.size() > 0){
|
Map<String, CacheTreeNode> map = new TreeMap<String, CacheTreeNode>();
|
for(S_dict_data code : list){
|
map.put(code.getDict_code().toString(), toCacheTreeNode(code));
|
}
|
return map;
|
} else
|
return null;
|
}
|
|
private class SortComparator implements Comparator<S_dict_data> {
|
@Override
|
public int compare(S_dict_data o1, S_dict_data o2) {
|
return (int)(o1.getDict_sort() - o2.getDict_sort());
|
}
|
}
|
private class NodeComparator implements Comparator<CacheTreeNode>{
|
@Override
|
public int compare(CacheTreeNode o1, CacheTreeNode o2) {
|
S_dict_data n1 = (S_dict_data)o1.getSource();
|
S_dict_data n2 = (S_dict_data)o2.getSource();
|
return (int)(n1.getDict_sort() - n2.getDict_sort());
|
}
|
}
|
|
public void setCodeService(CodeServiceImpl codeService) {
|
this.codeService = codeService;
|
}
|
|
private CodeServiceImpl codeService;
|
}
|
