临时中转

plus-admin/admin-console/src/test/java/BeanProcessor.java → plus-admin/admin-console/src/test/java/CustomBeanProcessorTest.java

-import cn.hutool.core.util.IdUtil;
 import cn.hutool.json.JSONArray;
 import cn.hutool.json.JSONObject;
 import cn.hutool.json.JSONUtil;
@@ -13,10 +12,14 @@ import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
+import resultmap.GridContainer;
+import resultmap.GridHeader;
+import resultmap.GridMapping;
+import resultmap.GridRow;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest(classes = ConsoleApplication.class)
-public class BeanProcessor {
+public class CustomBeanProcessorTest {
 
   @Autowired CoreFunctionDao coreFunctionDao;
 
@@ -25,7 +28,8 @@ public class BeanProcessor {
   @BeforeClass
   public static void init() {
     resultMap = new JSONObject();
-    resultMap.put("id", "resultmap");
+    resultMap.put("id", "core_route_map");
+
     JSONObject mapping = new JSONObject();
     mapping.put("id", "id");
     mapping.put("parentId", "parent_id");
@@ -36,21 +40,33 @@ public class BeanProcessor {
     JSONObject objMap = new JSONObject();
     objMap.put("title", "title");
     objMap.put("icon", "icon");
-    objMap.put("resultType", CoreRouteMeta.class.getCanonicalName());
-    mapping.put("obj_mapping" + IdUtil.fastSimpleUUID(), objMap);
 
     JSONArray listMap = new JSONArray();
     JSONObject listInnerMap = new JSONObject();
     listInnerMap.put("id", "role_id");
     listMap.add(listInnerMap);
-    mapping.put("list_mapping" + IdUtil.fastSimpleUUID(), listMap);
+    objMap.put("roles", listMap);
+
+    objMap.put("resultType", CoreRouteMeta.class.getCanonicalName());
 
-    resultMap.put("map", mapping);
+    mapping.put("meta", objMap);
+    mapping.put("resultType", CoreRoute.class.getCanonicalName());
+
+    resultMap.put("mapping", mapping);
   }
 
   @Test
   public void maptest() {
     List<CoreRoute> routesList = coreFunctionDao.getAllRoutes();
-    System.out.println(JSONUtil.toJsonStr(resultMap));
+    System.out.println(JSONUtil.toJsonPrettyStr(resultMap));
+    GridMapping gridMapping = new GridMapping(resultMap);
+
+    GridHeader gridHeader = gridMapping.getHeader();
+    System.out.println(gridHeader);
+
+    GridRow gridRow = new GridRow(gridHeader);
+    System.out.println(gridRow);
+    GridContainer gridContainer = new GridContainer();
+    gridMapping.setContainer(gridContainer);
   }
 }

plus-admin/admin-console/src/test/java/resultmap/GridBox.java

+package resultmap;
+
+import java.util.Map;
+
+/**
+ * 网格格子，结果集映射的java类型中的基本类型属性，都应该在一个格子中。<br/>
+ * 非基本类型的属性字段，应该内嵌一个网格容器
+ * <br/>
+ * 包含：值映射map、映射类型、最关键的obj key<br/>
+ * objkey 决定了数据库结果集的多条重复记录会被唯一记录成一个对象。
+ * */
+public class GridBox extends GridContainer {
+
+  /** 对应的属性与数据库中值的映射，用于map to Bean 转换 */
+  Map<String, Object> beanMap;
+
+  /** 映射类型*/
+  String resultType;
+
+  /** 数据库记录对应的唯一key，用 beanMap 中所有非null值的hashcode相加得出*/
+  String objKey;
+
+  /** 嵌套的网格容器，说明结果集的映射中有个集合属性字段*/
+  GridContainer nestedContainer;
+
+  GridRow belongRow;
+
+  public Map<String, Object> getBeanMap() {
+    return beanMap;
+  }
+
+  public void setBeanMap(Map<String, Object> beanMap) {
+    this.beanMap = beanMap;
+  }
+
+  public String getResultType() {
+    return resultType;
+  }
+
+  public void setResultType(String resultType) {
+    this.resultType = resultType;
+  }
+
+  public String getObjKey() {
+    return objKey;
+  }
+
+  public void setObjKey(String objKey) {
+    this.objKey = objKey;
+  }
+
+  public GridContainer getNestedContainer() {
+    return nestedContainer;
+  }
+
+  public void setNestedContainer(GridContainer nestedContainer) {
+    this.nestedContainer = nestedContainer;
+  }
+
+  public GridRow getBelongRow() {
+    return belongRow;
+  }
+
+  public void setBelongRow(GridRow belongRow) {
+    this.belongRow = belongRow;
+  }
+}
\ No newline at end of file

plus-admin/admin-console/src/test/java/resultmap/GridContainer.java

+package resultmap;
+
+import cn.hutool.core.collection.CollUtil;
+import java.util.List;
+
+/** 网格容器，仅仅存放网格行，也只存放网格行 */
+public class GridContainer {
+
+  List<GridRow> gridRows = CollUtil.newArrayList();
+
+  int count;
+
+  GridContainer parentContainer;
+
+  public List<GridRow> getGridRows() {
+    return gridRows;
+  }
+
+  public void setGridRows(List<GridRow> gridRows) {
+    this.gridRows = gridRows;
+  }
+
+  public int getCount() {
+    return count;
+  }
+
+  public void setCount(int count) {
+    this.count = count;
+  }
+
+  public GridContainer getParentContainer() {
+    return parentContainer;
+  }
+
+  public void setParentContainer(GridContainer parentContainer) {
+    this.parentContainer = parentContainer;
+  }
+}

plus-admin/admin-console/src/test/java/resultmap/GridHeader.java

+package resultmap;
+
+import static cn.hutool.core.util.StrUtil.EMPTY;
+import static cn.hutool.core.util.StrUtil.isNotBlank;
+import static java.util.Optional.ofNullable;
+
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.ClassUtil;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * 网格头，保存了属性与列的映射关系，以及映射的java类型。<br>
+ * 内嵌的网格头，内嵌网格头的映射java类型，是否是映射至List集合字段
+ */
+public class GridHeader {
+
+  /** java属性名与数据库列名的对应。顺序：prop:column */
+  Map<String, String> javaToJdbcMap;
+
+  /** 映射java类型,如果该值为空，代表为基础类型，并且忽视javaToJdbcMap中的key，因为此刻是基本类型的List， */
+  String resultType;
+
+  /** 嵌套类型的网格头 */
+  GridHeader nestedHeader;
+
+  /** 嵌套类型的网格头 */
+  GridHeader parentHeader;
+
+  /** 嵌套字段属性名 */
+  String nestedPropName;
+
+  /** 嵌套类型是否是一个集合 */
+  boolean isCollection = false;
+
+  /** 网格头所属的网格映射 */
+  GridMapping belongMapping;
+
+  public GridHeader(Map<String, Object> resultMapping) {
+    javaToJdbcMap = new HashMap<String, String>();
+    processResultMapping(resultMapping);
+  }
+
+  public Map<String, String> getJavaToJdbcMap() {
+    return javaToJdbcMap;
+  }
+
+  public void setJavaToJdbcMap(Map<String, String> javaToJdbcMap) {
+    this.javaToJdbcMap = javaToJdbcMap;
+  }
+
+  public String getResultType() {
+    return resultType;
+  }
+
+  public void setResultType(String resultType) {
+    this.resultType = resultType;
+  }
+
+  public GridHeader getNestedHeader() {
+    return nestedHeader;
+  }
+
+  public void setNestedHeader(GridHeader nestedHeader) {
+    this.nestedHeader = nestedHeader;
+  }
+
+  public GridHeader getParentHeader() {
+    return parentHeader;
+  }
+
+  public void setParentHeader(GridHeader parentHeader) {
+    this.parentHeader = parentHeader;
+  }
+
+  public String getNestedPropName() {
+    return nestedPropName;
+  }
+
+  public void setNestedPropName(String nestedPropName) {
+    this.nestedPropName = nestedPropName;
+  }
+
+  public boolean getIsCollection() {
+    return isCollection;
+  }
+
+  public void setIsCollection(boolean isCollection) {
+    this.isCollection = isCollection;
+  }
+
+  public GridMapping getBelongMapping() {
+    return belongMapping;
+  }
+
+  public void setBelongMapping(GridMapping belongMapping) {
+    this.belongMapping = belongMapping;
+  }
+
+  private void processResultMapping(Map<String, Object> resultMapping) {
+    Set<Entry<String, Object>> entrySet = resultMapping.entrySet();
+    this.setResultType(ofNullable(resultMapping.get("resultType")).orElse(EMPTY).toString());
+    for (Entry<String, Object> objectEntry : entrySet) {
+      String key = objectEntry.getKey();
+      Object value = objectEntry.getValue();
+      Class<?> valClass = ClassUtil.getClass(value);
+      if (List.class.isAssignableFrom(valClass)) {
+        /*生成嵌套网格头，此嵌套网格头的类型对应集合字段*/
+        Map<String, Object> nestedMapping =
+            (Map<String, Object>) ((List) value).stream().findFirst().orElse(MapUtil.newHashMap(0));
+        GridHeader nestedHeader = new GridHeader(nestedMapping);
+        nestedHeader.setIsCollection(true);
+        nestedHeader.setNestedPropName(key);
+        nestedHeader.setBelongMapping(this.getBelongMapping());
+        this.setNestedHeader(nestedHeader);
+        nestedHeader.setParentHeader(this);
+      } else if (Map.class.isAssignableFrom(valClass)) {
+        /*生成嵌套网格头，此嵌套网格头的类型对应单个对象字段*/
+        Map<String, Object> nestedMapping = (Map<String, Object>) value;
+        GridHeader nestedHeader = new GridHeader(nestedMapping);
+        nestedHeader.setIsCollection(false);
+        nestedHeader.setNestedPropName(key);
+        nestedHeader.setBelongMapping(this.getBelongMapping());
+        this.setNestedHeader(nestedHeader);
+        nestedHeader.setParentHeader(this);
+      } else if (isNotBlank(key) || (null != value && isNotBlank(String.valueOf(value)))) {
+        javaToJdbcMap.put(key, String.valueOf(value));
+      }
+    }
+  }
+}

plus-admin/admin-console/src/test/java/resultmap/GridMapping.java

+package resultmap;
+
+import static cn.hutool.core.util.StrUtil.EMPTY;
+import static java.util.Optional.ofNullable;
+
+import cn.hutool.core.lang.Assert;
+import cn.hutool.json.JSON;
+import cn.hutool.json.JSONUtil;
+import java.util.Map;
+
+/** 网格映射数据结构： 包含一个网格头 {@link GridHeader}和网格容器/体{@link GridContainer} */
+public class GridMapping extends GridContainer {
+  /** 映射id */
+  String mappingId;
+
+  /** 映射类型 */
+  String resultType;
+
+  /** 网格头 */
+  GridHeader header;
+
+  /** 网格容器 */
+  GridContainer container;
+
+  public GridMapping(Map<String, Object> resultMapping) {
+    JSON parse = JSONUtil.parse(resultMapping);
+    String id = ofNullable(parse.getByPath("id")).orElse(EMPTY).toString();
+    String resultType = ofNullable(parse.getByPath("mapping.resultType")).orElse(EMPTY).toString();
+    Assert.notBlank(id, "result mapping must have [id].");
+    Assert.notBlank(resultType, "result mapping must have [resultType].");
+    this.mappingId = id;
+    this.resultType = resultType;
+    this.header = new GridHeader((Map<String, Object>) parse.getByPath("mapping"));
+  }
+
+  public GridHeader getHeader() {
+    return header;
+  }
+
+  public void setHeader(GridHeader header) {
+    this.header = header;
+    this.header.setBelongMapping(this);
+  }
+
+  public GridContainer getContainer() {
+    return container;
+  }
+
+  public void setContainer(GridContainer container) {
+    this.container = container;
+    this.container.setParentContainer(this);
+  }
+
+  public String getMappingId() {
+    return mappingId;
+  }
+
+  public void setMappingId(String mappingId) {
+    this.mappingId = mappingId;
+  }
+
+  public String getResultType() {
+    return resultType;
+  }
+
+  public void setResultType(String resultType) {
+    this.resultType = resultType;
+  }
+}

plus-admin/admin-console/src/test/java/resultmap/GridRow.java

+package resultmap;
+
+import static java.util.Optional.ofNullable;
+
+import cn.hutool.core.collection.CollUtil;
+import java.util.List;
+
+/** 网格行，包含一个个格子<br> */
+public class GridRow {
+
+  /** 包含的格子 */
+  List<GridBox> gridBoxes = CollUtil.<GridBox>newArrayList();
+
+  GridBox rowObjBox;
+
+  /** 映射类型 */
+  String resultType;
+
+  String rowKey;
+
+  GridContainer belongContainer;
+
+  public GridRow() {}
+
+  public GridRow(GridHeader gridHeader) {
+    rowObjBox.setResultType(gridHeader.getResultType());
+    rowObjBox.setBelongRow(this);
+    generateGridRow(gridHeader);
+  }
+
+  public List<GridBox> getGridBoxes() {
+    return gridBoxes;
+  }
+
+  public void setGridBoxes(List<GridBox> gridBoxes) {
+    this.gridBoxes = gridBoxes;
+  }
+
+  public GridBox getRowObjBox() {
+    return rowObjBox;
+  }
+
+  public void setRowObjBox(GridBox rowObjBox) {
+    this.rowObjBox = rowObjBox;
+  }
+
+  public String getResultType() {
+    return resultType;
+  }
+
+  public void setResultType(String resultType) {
+    this.resultType = resultType;
+  }
+
+  public String getRowKey() {
+    return rowKey;
+  }
+
+  public void setRowKey(String rowKey) {
+    this.rowKey = rowKey;
+  }
+
+  public GridContainer getBelongContainer() {
+    return belongContainer;
+  }
+  public void setBelongContainer(GridContainer belongContainer) {
+    this.belongContainer = belongContainer;
+  }
+
+  /**
+   * 根据网格头，生成对应的网格行结构
+   *
+   * @return
+   */
+  private GridBox generateGridRow(GridHeader gridHeader) {
+    ofNullable(gridHeader.getNestedHeader())
+        .ifPresent(
+            nestedHeader -> {
+              generateGridRow(nestedHeader);
+            });
+
+    GridBox gridBox = new GridBox();
+
+    if (gridHeader.getIsCollection()) {
+      GridContainer nestedContainer = new GridContainer();
+      GridRow nestedRow = new GridRow();
+      GridBox nestedBox = new GridBox();
+
+      nestedContainer.getGridRows().add(nestedRow);
+      nestedContainer.setParentContainer(gridBox);
+
+      nestedRow.getGridBoxes().add(nestedBox);
+
+      nestedBox.setBelongRow(nestedRow);
+      nestedBox.setResultType(gridHeader.getResultType());
+
+      /*嵌套和非嵌套只能存在一个*/
+      gridBox.setNestedContainer(nestedContainer);
+      gridBox.setBeanMap(null);
+    } else {
+      gridBox.setResultType(gridHeader.getResultType());
+    }
+
+    return gridBox;
+  }
+}