规则分类直接展开到最细的层次

src/main/java/com/diagbot/aggregate/RuleAggregate.java

@@ -59,16 +59,26 @@ public class RuleAggregate {
                                 ruleConditionDTO.setRuleGroup(ruleGroup);
                                 //结果判空第三层条件明细
                                 if (ListUtil.isNotEmpty(map.get(ruleGroup))) {
+                                    List<List<RuleBaseDTO>> ruleBaseList = new ArrayList<>();
                                     for (RuleConditionInitDTO ruleConditionInitDTO : map.get(ruleGroup)) {
                                         ruleConditionDTO.setMsg(ruleConditionInitDTO.getMsg());
-                                        //todo
-                                        RuleBaseDTO ruleBaseDTO = new RuleBaseDTO();
                                         List<RuleBaseInitDTO> ruleBaseInitDTOList = ruleBaseInits.get(ruleConditionInitDTO.getRuleBaseId());
-                                        BeanUtil.copyProperties(ruleBaseInits.get(ruleConditionInitDTO.getRuleBaseId()), ruleBaseDTO);
-                                        ruleConditionDTO.getRuleBaseDTOList().add(ruleBaseDTO);
+                                        if (ListUtil.isNotEmpty(ruleBaseInitDTOList)) {
+                                            List<RuleBaseDTO> ruleBaseDTOList = BeanUtil.listCopyTo(ruleBaseInitDTOList, RuleBaseDTO.class);
+                                            ruleBaseList.add(ruleBaseDTOList);
+                                        }
+                                    }
+                                    //笛卡尔积
+                                    List<List<RuleBaseDTO>> ruleBaseGroup = new ArrayList<>();
+                                    descartes(ruleBaseList, ruleBaseGroup, 0, new ArrayList<>());
+                                    for (List<RuleBaseDTO> ruleBaseDTOList : ruleBaseGroup) {
+                                        RuleConditionDTO ruleConditionDTO1 = new RuleConditionDTO();
+                                        BeanUtil.copyProperties(ruleConditionDTO, ruleConditionDTO1);
+                                        ruleConditionDTO1.getRuleBaseDTOList().addAll(ruleBaseDTOList);
+                                        ruleDTO.getRuleConditionDTOList().add(ruleConditionDTO1);
                                     }
                                 }
-                                ruleDTO.getRuleConditionDTOList().add(ruleConditionDTO);
+
                             }
                         }
                     } else {
@@ -92,10 +102,10 @@ public class RuleAggregate {
             @DataConsumer("getRuleInitNotHaveClass") List<RuleInitDTO> ruleNotHaveClass,
             @DataConsumer("getRuleInitHaveClass") List<RuleInitDTO> ruleHaveClass) {
         List<RuleInitDTO> list = new ArrayList<>();
-        if (ListUtil.isNotEmpty(ruleNotHaveClass)){
+        if (ListUtil.isNotEmpty(ruleNotHaveClass)) {
             list.addAll(ruleNotHaveClass);
         }
-        if (ListUtil.isNotEmpty(ruleHaveClass)){
+        if (ListUtil.isNotEmpty(ruleHaveClass)) {
             list.addAll(ruleHaveClass);
         }
         return EntityUtil.makeEntityListMap(list, "conceptGroup");
@@ -117,10 +127,10 @@ public class RuleAggregate {
             @DataConsumer("getRuleBaseInitNotHaveClass") List<RuleBaseInitDTO> ruleBaseNotHaveClass,
             @DataConsumer("getRuleBaseInitHaveClass") List<RuleBaseInitDTO> ruleBaseHaveClass) {
         List<RuleBaseInitDTO> list = new ArrayList<>();
-        if (ListUtil.isNotEmpty(ruleBaseNotHaveClass)){
+        if (ListUtil.isNotEmpty(ruleBaseNotHaveClass)) {
             list.addAll(ruleBaseNotHaveClass);
         }
-        if (ListUtil.isNotEmpty(ruleBaseHaveClass)){
+        if (ListUtil.isNotEmpty(ruleBaseHaveClass)) {
             list.addAll(ruleBaseHaveClass);
         }
         return EntityUtil.makeEntityListMap(list, "ruleBaseId");
@@ -147,4 +157,66 @@ public class RuleAggregate {
         return klRuleFacade.getRuleBaseInitDTOHaveClass();
     }
 
+    /**
+     * Discription: 笛卡尔乘积算法
+     * 把一个List{[1,2],[A,B],[a,b]} 转化成
+     * List{[1,A,a],[1,A,b],[1,B,a],[1,B,b],[2,A,a],[2,A,b],[2,B,a],[2,B,b]} 数组输出
+     *
+     * @param dimensionValue 原List
+     * @param result         通过乘积转化后的数组
+     * @param layer          中间参数
+     * @param currentList    中间参数
+     */
+    public static <T> void descartes(List<List<T>> dimensionValue, List<List<T>> result, int layer, List<T> currentList) {
+        if (layer < dimensionValue.size() - 1) {
+            if (dimensionValue.get(layer).size() == 0) {
+                descartes(dimensionValue, result, layer + 1, currentList);
+            } else {
+                for (int i = 0; i < dimensionValue.get(layer).size(); i++) {
+                    List<T> list = new ArrayList<T>(currentList);
+                    list.add(dimensionValue.get(layer).get(i));
+                    descartes(dimensionValue, result, layer + 1, list);
+                }
+            }
+        } else if (layer == dimensionValue.size() - 1) {
+            if (dimensionValue.get(layer).size() == 0) {
+                result.add(currentList);
+            } else {
+                for (int i = 0; i < dimensionValue.get(layer).size(); i++) {
+                    List<T> list = new ArrayList<T>(currentList);
+                    list.add(dimensionValue.get(layer).get(i));
+                    result.add(list);
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        List<List<RuleBaseDTO>> ruleBaseList = new ArrayList<>();
+        List<RuleBaseDTO> ruleBaseDTOListA = new ArrayList<>();
+        RuleBaseDTO baseDTOA = new RuleBaseDTO();
+        baseDTOA.setBaseLibName("A");
+        ruleBaseDTOListA.add(baseDTOA);
+        RuleBaseDTO baseDTOB = new RuleBaseDTO();
+        baseDTOB.setBaseLibName("B");
+        ruleBaseDTOListA.add(baseDTOB);
+        List<RuleBaseDTO> ruleBaseDTOListC = BeanUtil.listCopyTo(ruleBaseDTOListA, RuleBaseDTO.class);
+        ruleBaseList.add(ruleBaseDTOListC);
+        RuleBaseDTO baseDTOC = new RuleBaseDTO();
+        baseDTOC.setBaseLibName("C");
+        ruleBaseDTOListA.add(baseDTOC);
+        ruleBaseList.add(ruleBaseDTOListA);
+        List<RuleBaseDTO> ruleBaseDTOList1 = new ArrayList<>();
+        RuleBaseDTO baseDTO1 = new RuleBaseDTO();
+        baseDTO1.setBaseLibName("1");
+        ruleBaseDTOList1.add(baseDTO1);
+        RuleBaseDTO baseDTO2 = new RuleBaseDTO();
+        baseDTO2.setBaseLibName("2");
+        ruleBaseDTOList1.add(baseDTO2);
+        ruleBaseList.add(ruleBaseDTOList1);
+        List<List<RuleBaseDTO>> ruleBaseGroup = new ArrayList<>();
+        descartes(ruleBaseList, ruleBaseGroup, 0, new ArrayList<>());
+        System.out.println();
+    }
+
 }