feat: 迁移国内标准法规部分1

2021-06-02 21:39:20 +08:00
parent ac33a531ec
commit 4cc558befc
140 changed files with 12514 additions and 58 deletions
@@ -0,0 +1,32 @@
+package com.adc.da.utils.tree;
+
+import java.util.List;
+
+/**
+ * 操作树的接口类
+ *
+ */
+public interface ITree {
+    /**
+     * 获取构建数的list，因为根节点可能不止一个，所有返回List
+     * 获取的结构与getRoot基本一致，但是后边增加了另外的数据，不建议调用
+     *
+     * @return
+     */
+    List<TreeNode> getTree();
+
+    /**
+     * 获取根节点树结构，因为根节点可能不止一个，所有返回List
+     *
+     * @return
+     */
+    List<TreeNode> getRoot();
+
+    /**
+     * 获取指定节点数据
+     *
+     * @param nodeId
+     * @return
+     */
+    TreeNode getTreeNode(String nodeId);
+}
@@ -0,0 +1,43 @@
+package com.adc.da.utils.tree;
+
+/**
+ * 需要实现树的实体类需要实现的接口，获取关键数据
+ *
+ */
+public interface ITreeNode<T> {
+    /**
+     * TreeNode获取nodeId
+     *
+     * @return
+     */
+    String getNodeId();
+
+    /**
+     * TreeNode获取nodeName
+     *
+     * @return
+     */
+    String getNodeName();
+
+    /**
+     * TreeNode获取nodeParentId（父id）
+     *
+     * @return
+     */
+    String getNodeParentId();
+
+    /**
+     * TreeNode获取orderNum(排序字段用于排序)
+     *
+     * @return
+     */
+    Integer getOrderNum();
+
+    /**
+     * TreeNode获取nodeLevel(当前属于第几层级)
+     *
+     * @return
+     */
+    Integer getNodeLevel();
+
+}
@@ -0,0 +1,132 @@
+package com.adc.da.utils.tree;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.*;
+
+/**
+ * 构建树形建构
+ */
+public class Tree implements ITree {
+    /**
+     * 用于存放treeNode的Map
+     */
+    private LinkedHashMap<String, TreeNode> treeNodesMap = new LinkedHashMap<>();
+    /**
+     * 用于存放treeNode的list
+     */
+    private List<TreeNode> treeNodesList = new ArrayList<>();
+
+    /**
+     * 构造方法
+     *
+     * @param list
+     */
+    public Tree(List<ITreeNode> list) {
+        initTreeNodeMap(list);
+        initTreeNodeList();
+    }
+
+    /**
+     * 将List对象数据转为TreeNodeMap
+     *
+     * @param list
+     */
+    private void initTreeNodeMap(List<ITreeNode> list) {
+        TreeNode treeNode;
+        for (ITreeNode item : list) {
+            treeNode = new TreeNode(item);
+            treeNode.setLastNodeNum(1);
+            treeNodesMap.put(treeNode.getNodeId(), treeNode);
+        }
+        Iterator<TreeNode> iterator = treeNodesMap.values().iterator();
+        TreeNode parentTreeNode;
+        while (iterator.hasNext()) {
+            treeNode = iterator.next();
+            if (StringUtils.isEmpty(treeNode.getParentNodeId())) {
+                continue;
+            }
+            parentTreeNode = treeNodesMap.get(treeNode.getParentNodeId());
+            if (parentTreeNode != null) {
+                treeNode.setParent(parentTreeNode);
+                parentTreeNode.addChild(treeNode);
+                // 按照orderNum排序
+                Collections.sort(parentTreeNode.getChildren(), new OrdNamComparator());
+                // 判断这个节点是否是最子节点
+                if (treeNode.getChildren().size() == 0) {
+                    treeNode.setLastNode(true);
+                }
+                // 计算每一个节点的最子节点的数量
+                List<TreeNode> children = parentTreeNode.getChildren();
+                if (children.size() > 0) {
+                    int sum = 0;
+                    for (TreeNode treeNode2 : children) {
+                        sum += treeNode2.getLastNodeNum();
+                    }
+                    parentTreeNode.setLastNodeNum(sum);
+                }
+            }
+        }
+    }
+
+    /**
+     * 根据treeNodesMap转为treeNodesList
+     */
+    private void initTreeNodeList() {
+        if (treeNodesList.size() > 0) {
+            return;
+        }
+        if (treeNodesMap.size() == 0) {
+            return;
+        }
+        Iterator<TreeNode> iterator = treeNodesMap.values().iterator();
+        TreeNode treeNode;
+        while (iterator.hasNext()) {
+            treeNode = iterator.next();
+            if (treeNode.getParent() == null) {
+                this.treeNodesList.add(treeNode);
+                this.treeNodesList.addAll(treeNode.getAllChildren());
+            }
+        }
+    }
+
+    @Override
+    public List<TreeNode> getTree() {
+        return this.treeNodesList;
+    }
+
+    @Override
+    public List<TreeNode> getRoot() {
+        List<TreeNode> rootList = new ArrayList<>();
+        if (this.treeNodesList.size() > 0) {
+            for (TreeNode node : treeNodesList) {
+                if (node.getParent() == null) {
+                    rootList.add(node);
+                    Collections.sort(rootList, new OrdNamComparator());
+                }
+            }
+        }
+        return rootList;
+    }
+
+    @Override
+    public TreeNode getTreeNode(String nodeId) {
+        return this.treeNodesMap.get(nodeId);
+    }
+}
+
+/**
+ * 自定义排序，按照orderNum排序
+ */
+class OrdNamComparator implements Comparator<TreeNode> {
+    @Override
+    public int compare(TreeNode t1, TreeNode t2) {
+        if (t1.getOrderNum() > t2.getOrderNum()) {
+            return 1;
+        }
+        if (t1.getOrderNum() < t2.getOrderNum()) {
+            return -1;
+        }
+        return t1.getNodeName().compareTo(t2.getNodeName());
+    }
+}
@@ -0,0 +1,187 @@
+package com.adc.da.utils.tree;
+
+import com.alibaba.fastjson.annotation.JSONField;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TreeNode {
+
+    /**
+     * 树节点ID
+     */
+    @JSONField(ordinal = 1)
+    private String nodeId;
+    /**
+     * 树节点名称
+     */
+    @JSONField(ordinal = 2)
+    private String nodeName;
+    /**
+     * 父节点ID
+     */
+    @JSONField(ordinal = 3)
+    private String parentNodeId;
+    /**
+     * 节点在树中的排序号
+     */
+    @JSONField(ordinal = 4)
+    private int orderNum;
+    /**
+     * 节点所在的层级
+     */
+    @JSONField(ordinal = 5)
+    private int level;
+    /**
+     * 最子节点的数量
+     */
+    @JSONField(ordinal = 6)
+    private int lastNodeNum;
+
+    /**
+     * 是否是最子节点
+     */
+    @JSONField(ordinal = 7)
+    private boolean lastNode;
+
+    /**
+     * 当前节点的儿子节点
+     */
+    @JSONField(ordinal = 8)
+    private List<TreeNode> children = new ArrayList<>();
+
+    /**
+     * 当前节点的完整路径
+     */
+    @JSONField(ordinal = 9)
+    private String completeName;
+
+    /**
+     * 当前节点的父级节点
+     * 转json的时候忽略此属性，因为此属性到前端无作用
+     */
+    @JSONField(serialize = false)
+    private TreeNode parent;
+
+    /**
+     * 当前节点的子孙节点
+     * 转json的时候忽略此属性，因为此属性到前端无作用
+     */
+    @JSONField(serialize = false)
+    private List<TreeNode> allChildren = new ArrayList<>();
+
+    public TreeNode(ITreeNode obj) {
+        this.nodeId = obj.getNodeId();
+        this.nodeName = obj.getNodeName();
+        this.parentNodeId = obj.getNodeParentId();
+        this.orderNum = obj.getOrderNum();
+        this.level = obj.getNodeLevel();
+    }
+
+    public TreeNode(TreeNode obj) {
+        this.orderNum = obj.getOrderNum();
+        this.level = obj.getLevel();
+        this.lastNodeNum = obj.getLastNodeNum();
+    }
+
+    public TreeNode() {
+    }
+
+    public void addChild(TreeNode treeNode) {
+        this.children.add(treeNode);
+    }
+
+    public void removeChild(TreeNode treeNode) {
+        this.children.remove(treeNode);
+    }
+
+    public String getNodeId() {
+        return nodeId;
+    }
+
+    public void setNodeId(String nodeId) {
+        this.nodeId = nodeId;
+    }
+
+    public String getNodeName() {
+        return nodeName;
+    }
+
+    public void setNodeName(String nodeName) {
+        this.nodeName = nodeName;
+    }
+
+    public String getParentNodeId() {
+        return parentNodeId;
+    }
+
+    public void setParentNodeId(String parentNodeId) {
+        this.parentNodeId = parentNodeId;
+    }
+
+    public int getLevel() {
+        return level;
+    }
+
+    public void setLevel(int level) {
+        this.level = level;
+    }
+
+    public TreeNode getParent() {
+        return parent;
+    }
+
+    public void setParent(TreeNode parent) {
+        this.parent = parent;
+    }
+
+    public List<TreeNode> getChildren() {
+        return children;
+    }
+
+    public void setChildren(List<TreeNode> children) {
+        this.children = children;
+    }
+
+    public int getOrderNum() {
+        return orderNum;
+    }
+
+    public void setOrderNum(int orderNum) {
+        this.orderNum = orderNum;
+    }
+
+    public int getLastNodeNum() {
+        return lastNodeNum;
+    }
+
+    public void setLastNodeNum(int lastNodeNum) {
+        this.lastNodeNum = lastNodeNum;
+    }
+
+    public boolean isLastNode() {
+        return lastNode;
+    }
+
+    public void setLastNode(boolean lastNode) {
+        this.lastNode = lastNode;
+    }
+
+    public List<TreeNode> getAllChildren() {
+        if (this.allChildren.isEmpty()) {
+            for (TreeNode treeNode : this.children) {
+                this.allChildren.add(treeNode);
+                this.allChildren.addAll(treeNode.getAllChildren());
+            }
+        }
+        return this.allChildren;
+    }
+
+    public String getCompleteName() {
+        return completeName;
+    }
+
+    public void setCompleteName(String completeName) {
+        this.completeName = completeName;
+    }
+}