【8.3.0】【scanner】修复不能解析List<T>的问题

kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/enums/FieldTypeEnum.java

@@ -61,9 +61,14 @@ public enum FieldTypeEnum {
     OBJECT_WITH_GENERIC(50),
 
     /**
-     * 带T类型的泛型对象，需要从所属类上再拿到具体泛型的类型，例如字段SomeEntity<T>，List<T>，T
+     * 带T类型的泛型对象，需要从所属类上再拿到具体泛型的类型，例如字段T
      */
-    WITH_UNKNOWN_GENERIC(60),
+    WITH_UNKNOWN_OBJ_GENERIC(60),
+
+    /**
+     * 带T类型的泛型对象，需要从所属类上再拿到具体泛型的类型，例如字段List<T>
+     */
+    WITH_UNKNOWN_ARRAY_GENERIC(61),
 
     /**
      * Map类型，例如Map<String, Object>、Map<String, SysUser>

kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/pojo/clazz/ClassParseResult.java

@@ -19,6 +19,13 @@ public class ClassParseResult {
      */
     private FieldTypeEnum fieldTypeEnum;
 
+    /**
+     * 原始解析的type
+     * <p>
+     * 如果 FieldTypeEnum = FieldTypeEnum.OBJECT ，则这个字段代表object的类型
+     */
+    private Type originType;
+
     /**
      * 数组、集合、泛型的具体类型
      * <p>

kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/util/ClassTypeUtil.java

@@ -101,7 +101,7 @@ public class ClassTypeUtil {
         // 带T的参数，例如解析到ResponseData<T>中的data字段就是这种情况
         // 这种情况，单纯从参数中是拿不到T的，需要从外部的参数中获取T的类型
         else if (type.getTypeName().equals("T")) {
-            return new ClassParseResult(FieldTypeEnum.WITH_UNKNOWN_GENERIC, null);
+            return new ClassParseResult(FieldTypeEnum.WITH_UNKNOWN_OBJ_GENERIC, null);
         }
 
         // 其他情况，既不是class也不是ParameterizedType

kernel-d-scanner/scanner-api/src/main/java/cn/stylefeng/roses/kernel/scanner/api/factory/ClassMetaFactory.java

@@ -36,13 +36,20 @@ public class ClassMetaFactory {
      * @since 2022/1/13 13:51
      */
     public static FieldMetadata beginCreateFieldMetadata(Type type, String uuid) {
-
-        // 获取类型的枚举
         ClassParseResult classParseResult = AdvancedClassTypeUtil.getClassFieldType(type);
+        return beginCreateFieldMetadata(classParseResult, uuid);
+    }
 
+    /**
+     * 通过传入ClassParseResult进行字段校验
+     *
+     * @author fengshuonan
+     * @since 2024/8/7 16:27
+     */
+    public static FieldMetadata beginCreateFieldMetadata(ClassParseResult classParseResult, String uuid) {
         // 1. 如果是基础类型，直接渲染结果
         if (FieldTypeEnum.BASIC.equals(classParseResult.getFieldTypeEnum())) {
-            return MetadataCreateFactory.createBaseClassMetadata((Class<?>) type, classParseResult.getFieldTypeEnum(), uuid);
+            return MetadataCreateFactory.createBaseClassMetadata((Class<?>) classParseResult.getOriginType(), classParseResult.getFieldTypeEnum(), uuid);
         }
 
         // 2. 如果是数组类型，则先创建一个数组类型的元数据，再获取数组具体的类型，再继续解析数组的类型
@@ -58,10 +65,10 @@ public class ClassMetaFactory {
         // 4. 如果是Object类型，则找到对象的所有的子字段，填充到genericFieldMetadata这个字段中
         else if (FieldTypeEnum.OBJECT.equals(classParseResult.getFieldTypeEnum())) {
             // 获取对象的类信息
-            Class<?> clazz = (Class<?>) type;
+            Class<?> clazz = (Class<?>) classParseResult.getOriginType();
 
             // 创建对象的基础信息
-            FieldMetadata currentClassMetaData = MetadataCreateFactory.createBaseClassMetadata((Class<?>) type, classParseResult.getFieldTypeEnum(), uuid);
+            FieldMetadata currentClassMetaData = MetadataCreateFactory.createBaseClassMetadata(clazz, classParseResult.getFieldTypeEnum(), uuid);
 
             // 如果被初始化过，则不继续进行解析
             if (MetadataContext.ensureFieldClassHaveParse(uuid, clazz)) {
@@ -85,21 +92,24 @@ public class ClassMetaFactory {
             FieldMetadata rawTypeMetadata = ClassMetaFactory.beginCreateFieldMetadata(rawTypeClass, uuid);
 
             // **这里需要遍历一下所有字段，如果有T类型，则需要单独配置一下T类型的FieldMetadata**
-            // 1. 遍历所有字段
+            // 遍历所有字段
             Set<FieldMetadata> genericFieldMetadata = rawTypeMetadata.getGenericFieldMetadata();
             if (ObjectUtil.isEmpty(genericFieldMetadata)) {
                 return rawTypeMetadata;
             }
             for (FieldMetadata subField : genericFieldMetadata) {
-                if (!FieldTypeEnum.WITH_UNKNOWN_GENERIC.getCode().equals(subField.getFieldType())) {
+
-                    continue;
+                // 1. 如果是带T的对象，则需要获取泛型的具体类型
+                if (FieldTypeEnum.WITH_UNKNOWN_OBJ_GENERIC.getCode().equals(subField.getFieldType())) {
+                    Type subFieldGenericType = classParseResult.getGenericType();
+                    ClassMetaFactory.getGenericObjFieldTypeAndFillOriginMeta(uuid, subField, subFieldGenericType);
                 }
 
-                // 2. 获取这个字段的类型，也就是泛型对象的泛型
+                // 2. 如果是List<T>也一样，需要从这里获取泛型的具体类型
-                Type subFieldType = classParseResult.getGenericType();
+                if (FieldTypeEnum.WITH_UNKNOWN_ARRAY_GENERIC.getCode().equals(subField.getFieldType())) {
-
+                    Type arrayRealGenericType = classParseResult.getGenericType();
-                // 3. 继续进行这个字段的解析，判断是否需要填充子字段或者数组字段
+                    ClassMetaFactory.getGenericListFieldTypeAndFillOriginMeta(uuid, subField, arrayRealGenericType);
-                ClassMetaFactory.getSubFieldTypeAndFillOriginMeta(uuid, subField, subFieldType);
+                }
             }
             return rawTypeMetadata;
         }
@@ -210,7 +220,7 @@ public class ClassMetaFactory {
      * @author fengshuonan
      * @since 2024/8/7 15:11
      */
-    private static void getSubFieldTypeAndFillOriginMeta(String uuid, FieldMetadata subField, Type subFieldType) {
+    private static void getGenericObjFieldTypeAndFillOriginMeta(String uuid, FieldMetadata subField, Type subFieldType) {
         FieldMetadata realSubFieldMetadata = ClassMetaFactory.beginCreateFieldMetadata(subFieldType, uuid);
         subField.setFieldClassType(realSubFieldMetadata.getFieldClassType());
         subField.setFieldClassPath(realSubFieldMetadata.getFieldClassPath());
@@ -218,4 +228,18 @@ public class ClassMetaFactory {
         subField.setGenericFieldMetadata(realSubFieldMetadata.getGenericFieldMetadata());
         subField.setArrayFieldMetadata(realSubFieldMetadata.getArrayFieldMetadata());
     }
+
+    /**
+     * 填充泛型子字段的类型和信息，并填充原有的解析字段的部分内容
+     *
+     * @author fengshuonan
+     * @since 2024/8/7 16:32
+     */
+    private static void getGenericListFieldTypeAndFillOriginMeta(String uuid, FieldMetadata subField, Type arrayRealGenericType) {
+        ClassParseResult arrayRealGenericTypeResult = new ClassParseResult(FieldTypeEnum.ARRAY, arrayRealGenericType);
+        FieldMetadata fieldMetadata = ClassMetaFactory.beginCreateFieldMetadata(arrayRealGenericTypeResult, uuid);
+        subField.setFieldType(FieldTypeEnum.ARRAY.getCode());
+        subField.setArrayFieldMetadata(fieldMetadata.getArrayFieldMetadata());
+    }
+
 }

kernel-d-scanner/scanner-api/src/main/java/cn/stylefeng/roses/kernel/scanner/api/util/AdvancedClassTypeUtil.java

@@ -87,7 +87,9 @@ public class AdvancedClassTypeUtil {
 
             // 判断是否是基本类型，如果是Map或者Object，也认定为基本类型，不解析他们的字段
             if (ClassUtil.isSimpleValueType(clazz)) {
-                return new ClassParseResult(FieldTypeEnum.BASIC, null);
+                ClassParseResult classParseResult = new ClassParseResult(FieldTypeEnum.BASIC, null);
+                classParseResult.setOriginType(type);
+                return classParseResult;
             }
 
             // 判断是否是数组类型
@@ -104,7 +106,9 @@ public class AdvancedClassTypeUtil {
 
             // 如果是实体对象类型
             else if (AdvancedClassTypeUtil.ensureEntityFlag(clazz)) {
-                return new ClassParseResult(FieldTypeEnum.OBJECT, null);
+                ClassParseResult classParseResult = new ClassParseResult(FieldTypeEnum.OBJECT, null);
+                classParseResult.setOriginType(type);
+                return classParseResult;
             }
 
             // 其他类型，暂不处理
@@ -127,6 +131,9 @@ public class AdvancedClassTypeUtil {
 
             // 如果泛型主体是集合
             if (Collection.class.isAssignableFrom(rawTypeClass)) {
+                if (actualTypeArgument.getTypeName().equals("T")) {
+                    return new ClassParseResult(FieldTypeEnum.WITH_UNKNOWN_ARRAY_GENERIC, null);
+                }
                 return new ClassParseResult(FieldTypeEnum.COLLECTION, actualTypeArgument);
             }
 
@@ -149,7 +156,7 @@ public class AdvancedClassTypeUtil {
 
         // 带T的参数，例如解析到ResponseData<T>中的data字段就是这种情况
         else if (type.getTypeName().equals("T")) {
-            return new ClassParseResult(FieldTypeEnum.WITH_UNKNOWN_GENERIC, null);
+            return new ClassParseResult(FieldTypeEnum.WITH_UNKNOWN_OBJ_GENERIC, null);
         }
 
         // 其他情况，既不是class也不是ParameterizedType