-

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

+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.http.HttpUtil;
 import cn.hutool.json.JSONArray;
@@ -11,6 +12,7 @@ import com.ibeetl.admin.core.entity.CoreRoute;
 import com.ibeetl.admin.core.entity.CoreRouteMeta;
 import com.ibeetl.admin.core.util.CacheUtil;
 import java.time.ZonedDateTime;
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;

plus-admin/admin-console/src/test/java/processor/JsonBeanProcessor.java

 package processor;
 
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.ibeetl.admin.core.util.CacheUtil;
+import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
-import java.lang.reflect.Method;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
-import org.beetl.sql.core.BeetlSQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
 import org.beetl.sql.core.SQLManager;
-import org.beetl.sql.core.Tail;
-import org.beetl.sql.core.annotatoin.builder.AttributeBuilderHolder;
-import org.beetl.sql.core.annotatoin.builder.AttributeSelectBuilder;
-import org.beetl.sql.core.db.ClassAnnotation;
-import org.beetl.sql.core.db.DBStyle;
 import org.beetl.sql.core.kit.BeanKit;
 import org.beetl.sql.core.mapping.BeanProcessor;
-import org.beetl.sql.core.mapping.type.JavaSqlTypeHandler;
-import org.beetl.sql.core.mapping.type.TypeParameter;
+import resultmap.GridColumn;
+import resultmap.GridHeader;
 import resultmap.GridMapping;
+import resultmap.GridRow;
 
 public class JsonBeanProcessor extends BeanProcessor {
 
@@ -25,78 +28,108 @@ public class JsonBeanProcessor extends BeanProcessor {
     super(sm);
   }
 
+  @Override
+  public <T> List<T> toBeanList(String sqlId, ResultSet rs, Class<T> type) throws SQLException {
+    if (!rs.next()) {
+      return new ArrayList<T>(0);
+    }
+    List<T> results = new ArrayList<T>();
+    PropertyDescriptor[] props = this.propertyDescriptors(type);
+    ResultSetMetaData rsmd = rs.getMetaData();
+    int[] columnToProperty = this.mapColumnsToProperties(type, rsmd, props);
+
+    results.add(this.createBean(sqlId, rs, type, props, columnToProperty));
+
+    return results;
+  }
+
   /** 创建 一个新的对象，并从ResultSet初始化 */
   @Override
   protected <T> T createBean(
       String sqlId, ResultSet rs, Class<T> type, PropertyDescriptor[] props, int[] columnToProperty)
       throws SQLException {
     GridMapping gridMapping = (GridMapping) CacheUtil.get("Route_Mapping");
+    if (null == gridMapping) {
+      return super.createBean(sqlId, rs, type, props, columnToProperty);
+    }
 
-    T bean = this.newInstance(type);
-    ResultSetMetaData meta = rs.getMetaData();
-    TypeParameter tp = new TypeParameter(sqlId, this.dbName, type, rs, meta, 1);
-
-    for (int i = 1; i < columnToProperty.length; i++) {
-      // Array.fill数组为-1 ，-1则无对应name
-      tp.setIndex(i);
-      if (columnToProperty[i] == PROPERTY_NOT_FOUND) {
-        String key = rs.getMetaData().getColumnLabel(i);
-        if ((dbType == DBStyle.DB_ORACLE || dbType == DBStyle.DB_SQLSERVER)
-            && key.equalsIgnoreCase("beetl_rn")) {
-          // sql server 特殊处理，sql'server的翻页使用了额外列作为翻页参数，需要过滤
-          continue;
-        }
-
-        if (bean instanceof Tail) {
-          Tail bean2 = (Tail) bean;
-          Object value = noMappingValue(tp);
-          key = this.nc.getPropertyName(type, key);
-          bean2.set(key, value);
-        } else {
-          Method m = BeanKit.getTailMethod(type);
-          // 使用指定方法赋值
-          if (m != null) {
+    fillMappingRow(rs, gridMapping);
+    System.out.println(gridMapping);
+    return null;
+  }
 
-            Object value = noMappingValue(tp);
-            key = this.nc.getPropertyName(type, key);
-            try {
-              m.invoke(bean, key, value);
-            } catch (Exception ex) {
-              throw new BeetlSQLException(BeetlSQLException.TAIL_CALL_ERROR, ex);
-            }
-          } else {
-            // 忽略这个结果集
-          }
-        }
-        continue;
+  protected void fillMappingRow(ResultSet resultSet, GridMapping mapping) throws SQLException {
+    GridHeader header = mapping.getHeader();
+    mapping.nextRow();
+    /** flag：用来判断结果集是否应该 next()。可能后期应该改成CacheRowSet更好，这样可以直接操作结果集光标回退一行就行了。 */
+    Boolean flag = true;
+    while (true) {
+      if (flag && !resultSet.next()) {
+        break;
       }
+      resultSet.previous();
+      GridRow row;
+      if (!flag) {
+        row = mapping.nextRow();
+      } else {
+        row = CollUtil.getLast(mapping.getNestedRows());
+      }
+      flag = fillRowColumn(resultSet, header, row);
+    }
+  }
+  /** flag：用来判断结果集是否 next() */
+  protected boolean fillRowColumn(ResultSet resultSet, GridHeader header, GridRow row)
+      throws SQLException {
+    boolean flag = true;
+    Map<String, Object> tempBeanMap = MapUtil.newHashMap();
+    /*第一步、先处理当前可以处理的*/
+    Map<String, String> javaToJdbcMap = header.getJavaToJdbcMap();
+    Set<Entry<String, String>> entrySet = javaToJdbcMap.entrySet();
+    for (Entry<String, String> entry : entrySet) {
+      tempBeanMap.put(entry.getKey(), resultSet.getObject(entry.getValue()));
+    }
+    Integer rowKey = row.getRowKey();
+    Integer calculateKey = GridColumn.calculateKey(tempBeanMap);
+    if (ObjectUtil.notEqual(rowKey, calculateKey)) {
+      if (ObjectUtil.isNull(row.getBelongColumn())) {
+        flag = false;
+      } else {
+        GridRow generateRow = GridRow.generateRowByHeader(header);
+        generateRow.setBelongColumn(row.getBelongColumn());
 
-      // columnToProperty[i]取出对应的在PropertyDescriptor[]中的下标
-      PropertyDescriptor prop = props[columnToProperty[i]];
-      Class<?> propType = prop.getPropertyType();
-      tp.setTarget(propType);
-      ClassAnnotation ca = ClassAnnotation.getClassAnnotation(type);
-      Object value = null;
-      if (!ca.getColHandlers().isEmpty()) {
-        AttributeBuilderHolder holder =
-            (AttributeBuilderHolder) ca.getColHandlers().get(prop.getName());
-        if (holder != null && holder.supportSelectMapping()) {
-          value =
-              ((AttributeSelectBuilder) holder.getInstance())
-                  .toObject(this.sm, holder.getBeanAnnotaton(), sqlId, tp, prop);
-          this.callSetter(bean, prop, value, propType);
-          continue;
-        }
+        GridColumn tempColumn = new GridColumn();
+        tempColumn.setMappingHeader(header);
+        tempColumn.setResultType(header.getResultType());
+        tempColumn.setBelongRow(row);
+        tempColumn.setBeanMap(tempBeanMap);
+
+        generateRow.getNestedColumns().add(0, tempColumn);
+        row.getBelongColumn().getNestedRows().add(generateRow);
+        flag = true;
       }
-      JavaSqlTypeHandler handler = this.handlers.get(propType);
-      if (handler == null) {
-        handler = this.defaultHandler;
+    } else {
+      List<GridHeader> nestedHeaders = header.getNestedHeaders();
+      for (GridHeader nestedHeader : nestedHeaders) {
+        row = row.getGridColumnByMappingHeader(nestedHeader).getBelongRow();
+        flag = fillRowColumn(resultSet, nestedHeader, row);
       }
-      value = handler.getValue(tp);
-
-      this.callSetter(bean, prop, value, propType);
     }
+    return flag;
+  }
 
-    return bean;
+  /**
+   * 根据class取得属性描述PropertyDescriptor
+   *
+   * @param c
+   * @return
+   * @throws SQLException
+   */
+  private PropertyDescriptor[] propertyDescriptors(Class<?> c) throws SQLException {
+
+    try {
+      return BeanKit.propertyDescriptors(c);
+    } catch (IntrospectionException e) {
+      throw new SQLException("Bean introspection failed: " + e.getMessage());
+    }
   }
 }

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

 package resultmap;
 
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.RandomUtil;
 import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
@@ -18,12 +18,12 @@ import java.util.Set;
 public class GridColumn implements Serializable {
 
   /** 对应的属性与数据库中值的映射，用于map to Bean 转换 */
-  Map<String, Object> beanMap;
+  Map<String, Object> beanMap = MapUtil.newHashMap();
 
   /** 映射类型 */
   String resultType;
 
-  /** 数据库记录对应的唯一key，用 beanMap 中所有非null值的hashcode相加得出 */
+  /** 一个网格列包含一个对象中的所有数据列，通过对这些数据列进行hash得到数据列的唯一性 */
   Integer objKey;
 
   /** 包含的网格行 */
@@ -32,6 +32,8 @@ public class GridColumn implements Serializable {
   /** 归属的网格行 */
   GridRow belongRow;
 
+  GridHeader mappingHeader;
+
   public Map<String, Object> getBeanMap() {
     return beanMap;
   }
@@ -49,25 +51,18 @@ public class GridColumn implements Serializable {
   }
 
   public Integer getObjKey() {
-    int hs = 0;
-    if (CollUtil.isNotEmpty(nestedRows)) {
-      for (GridRow nestedRow : nestedRows) {
-        hs = hs + nestedRow.getRowKey();
-      }
-    } else {
-      Set<Entry<String, Object>> entrySet = beanMap.entrySet();
-      for (Entry<String, Object> entry : entrySet) {
-        if (ObjectUtil.isNull(entry.getValue())) continue;
-        hs += entry.getValue().hashCode();
-      }
-    }
-    hs = hs / RandomUtil.randomInt(100);
-    objKey = hs;
+    objKey = calculateKey(beanMap);
     return objKey;
   }
 
-  public void setObjKey(Integer objKey) {
-    this.objKey = objKey;
+  public static Integer calculateKey(Map<String, Object> map) {
+    int hs = Integer.MIN_VALUE;
+    Set<Entry<String, Object>> entrySet = map.entrySet();
+    for (Entry<String, Object> entry : entrySet) {
+      if (ObjectUtil.isNull(entry.getValue())) continue;
+      hs += entry.getValue().hashCode();
+    }
+    return hs / 42;
   }
 
   public List<GridRow> getNestedRows() {
@@ -85,4 +80,12 @@ public class GridColumn implements Serializable {
   public void setBelongRow(GridRow belongRow) {
     this.belongRow = belongRow;
   }
+
+  public void setMappingHeader(GridHeader mappingHeader) {
+    this.mappingHeader = mappingHeader;
+  }
+
+  public GridHeader getMappingHeader() {
+    return this.mappingHeader;
+  }
 }

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

@@ -11,12 +11,12 @@ import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
 
-/** 网格映射数据结构： 包含一个网格头 {@link GridHeader} */
+/** 网格映射数据结构： 包含一个网格头 {@link GridHeader}和多个网格行{@link GridRow} */
 public class GridMapping implements Serializable {
   /** 映射id */
   String mappingId;
 
-  /** 映射类型 */
+  /** 当前映射配置对应的class类型 */
   String resultType;
 
   /** 网格头 */

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

@@ -7,11 +7,11 @@ import java.util.List;
 
 /**
  * 网格行，包含一个个网格列<br>
- * 一行一个对象，或者java类中的一个对象字段
+ * 一个网格行，对应着SQL select查询出的一个Java的逻辑对象
  */
 public class GridRow implements Serializable {
 
-  /** 包含的列 */
+  /** 包含的列,第0个列代表的是当前整个类的映射，从0列之后是内部对象字段的映射 */
   List<GridColumn> nestedColumns = CollUtil.<GridColumn>newArrayList();
 
   /** 所属的列 */
@@ -20,6 +20,7 @@ public class GridRow implements Serializable {
   /** 映射对象的类型名 */
   String resultType;
 
+  /** 通过每个列的key进行hash得到一个唯一row id */
   Integer rowKey;
 
   public GridRow() {}
@@ -41,16 +42,7 @@ public class GridRow implements Serializable {
   }
 
   public Integer getRowKey() {
-    int hs = 0;
-    for (GridColumn nestedColumn : nestedColumns) {
-      hs = hs + nestedColumn.getObjKey();
-    }
-    rowKey = hs;
-    return rowKey;
-  }
-
-  public void setRowKey(Integer rowKey) {
-    this.rowKey = rowKey;
+    return this.nestedColumns.get(0).getObjKey();
   }
 
   public GridColumn getBelongColumn() {
@@ -62,7 +54,7 @@ public class GridRow implements Serializable {
   }
 
   /**
-   * 根据网格头，生成对应的网格行结构
+   * 根据网格头，生成对应的网格行结构。 行套列或者列套行再套列两种。
    *
    * @return
    */
@@ -71,12 +63,16 @@ public class GridRow implements Serializable {
       return null;
     }
     GridRow gridRow = new GridRow();
+    /*这个列才是真正的存储数据值的*/
     GridColumn gridColumn = new GridColumn();
+
     gridRow.getNestedColumns().add(gridColumn);
+
     gridColumn.setBelongRow(gridRow);
 
     List<GridHeader> headers = gridHeader.getNestedHeaders();
     for (GridHeader header : headers) {
+      /*这只是外部的一个容器性质的列*/
       GridColumn containerColumn = new GridColumn();
       GridRow nestedRow = generateRowByHeader(header);
 
@@ -87,8 +83,26 @@ public class GridRow implements Serializable {
       containerColumn.setBelongRow(gridRow);
     }
 
+    gridColumn.setMappingHeader(gridHeader);
     gridColumn.setResultType(gridHeader.getResultType());
     gridRow.setResultType(gridHeader.getResultType());
     return gridRow;
   }
+
+  public GridColumn getGridColumnByMappingHeader(GridHeader header) {
+    GridColumn obj = null;
+    for (GridColumn column : nestedColumns) {
+      if (CollUtil.isNotEmpty(column.getNestedRows())) {
+        List<GridRow> nestedRows = column.getNestedRows();
+        for (GridRow nestedRow : nestedRows) {
+          obj = nestedRow.getGridColumnByMappingHeader(header);
+        }
+      }
+      if (header.equals(column.getMappingHeader())) {
+        obj = column;
+      }
+    }
+    return obj;
+  }
+
 }