【8.3.0】【scanner】整理class类型解析的过程

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

@@ -1,7 +1,9 @@
 package cn.stylefeng.roses.kernel.rule.pojo.clazz;
 
 import cn.stylefeng.roses.kernel.rule.enums.FieldTypeEnum;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.lang.reflect.Type;
 
@@ -12,6 +14,8 @@ import java.lang.reflect.Type;
  * @since 2024/8/6 21:49
  */
 @Data
+@AllArgsConstructor
+@NoArgsConstructor
 public class ClassParseResult {
 
     /**

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

@@ -2,6 +2,7 @@ package cn.stylefeng.roses.kernel.rule.util;
 
 import cn.hutool.core.util.ClassUtil;
 import cn.stylefeng.roses.kernel.rule.enums.FieldTypeEnum;
+import cn.stylefeng.roses.kernel.rule.pojo.clazz.ClassParseResult;
 import lombok.extern.slf4j.Slf4j;
 
 import java.lang.reflect.ParameterizedType;
@@ -10,21 +11,23 @@ import java.util.Collection;
 import java.util.Map;
 
 /**
- * 获取类类型的工具
+ * 从新改良class类型解析
+ * <p>
+ * 返回的类型更简单，但是携带的信息更丰富一些，带具体的泛型的类型
  *
  * @author fengshuonan
- * @since 2022/1/14 16:42
+ * @since 2024/8/6 21:48
  */
 @Slf4j
 public class ClassTypeUtil {
 
     /**
-     * 获取类类型的类别
+     * 获取类的类型
      *
      * @author fengshuonan
-     * @since 2022/1/14 0:25
+     * @since 2024/8/6 21:49
      */
-    public static FieldTypeEnum getClassFieldType(Type type) {
+    public static ClassParseResult getClassFieldType(Type type) {
 
         // 如果是具体类，不带泛型
         if (type instanceof Class) {
@@ -33,34 +36,31 @@ public class ClassTypeUtil {
 
             // 判断是否是基本类型，如果是Map或者Object，也认定为基本类型，不解析他们的字段
             if (ClassUtil.isSimpleValueType(clazz)) {
-                return FieldTypeEnum.BASIC;
+                return new ClassParseResult(FieldTypeEnum.BASIC, null);
             }
 
             // 判断是否是数组类型
             else if (clazz.isArray()) {
                 // 获取array的具体类型
                 Class<?> componentType = clazz.getComponentType();
-                if (ClassUtil.isSimpleValueType(componentType)) {
+                return new ClassParseResult(FieldTypeEnum.ARRAY, componentType);
-                    return FieldTypeEnum.BASE_ARRAY;
-                } else {
-                    return FieldTypeEnum.ARRAY_WITH_OBJECT;
-                }
             }
 
             // 如果是集合类型，纯集合类型，不带泛型
             else if (Collection.class.isAssignableFrom(clazz)) {
-                return FieldTypeEnum.BASE_COLLECTION;
+                return new ClassParseResult(FieldTypeEnum.COLLECTION, null);
             }
 
             // 如果是Object类型，则认定为基本类型，不解析他的具体内容
-            else if (Object.class.equals(clazz)) {
+            // 【注意】如果是解析具体实体类型，用AdvancedClassTypeUtil类
-                return FieldTypeEnum.BASIC;
+            else if (Object.class.isAssignableFrom(clazz)) {
+                return new ClassParseResult(FieldTypeEnum.OBJECT, null);
             }
 
             // 其他类型，暂不处理
             else {
                 log.debug("类型是Class，但有处理不到的情况，打印出类的信息如下：{}", clazz.toGenericString());
-                return FieldTypeEnum.OTHER;
+                return new ClassParseResult(FieldTypeEnum.OTHER, null);
             }
         }
 
@@ -69,43 +69,45 @@ public class ClassTypeUtil {
 
             ParameterizedType parameterizedType = (ParameterizedType) type;
 
-            // 泛型类的主体
+            // 泛型的主体，例如 List<String>，主体是List
-            Type rawType = parameterizedType.getRawType();
+            Class<?> rawTypeClass = (Class<?>) parameterizedType.getRawType();
 
-            if (rawType instanceof Class<?>) {
+            // 泛型的类型，例如 List<String>，类型是String
-                Class<?> rawTypeClass = (Class<?>) rawType;
+            Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0];
 
-                // 如果泛型主体是集合
+            // 如果泛型主体是集合
-                if (Collection.class.isAssignableFrom(rawTypeClass)) {
+            if (Collection.class.isAssignableFrom(rawTypeClass)) {
-                    return FieldTypeEnum.COLLECTION_WITH_OBJECT;
+                return new ClassParseResult(FieldTypeEnum.COLLECTION, actualTypeArgument);
-                }
+            }
 
-                // 如果是map类型，则认定为基本类型，不做处理，不解析他的元数据
+            // 如果是map类型，则认定为基本类型，不做处理，不解析他的元数据
-                else if (Map.class.isAssignableFrom(rawTypeClass)) {
+            else if (Map.class.isAssignableFrom(rawTypeClass)) {
-                    return FieldTypeEnum.BASIC;
+                return new ClassParseResult(FieldTypeEnum.BASIC, null);
-                }
+            }
 
-                // 泛型的主体情况不确定，不处理
+            // 如果是Object类型，则认定为基本类型，不解析他的具体内容
-                else {
+            // 【注意】如果是解析具体实体类型，用AdvancedClassTypeUtil类
-                    log.debug("泛型的主体情况不确定，不处理，打印出rawTypeClass：{}", rawTypeClass.getName());
+            else if (Object.class.isAssignableFrom(rawTypeClass)) {
-                    return FieldTypeEnum.OTHER;
+                return new ClassParseResult(FieldTypeEnum.OBJECT_WITH_GENERIC, actualTypeArgument);
-                }
+            }
-            } else {
+
-                // 泛型的主体是别的类型
+            // 泛型的主体情况不确定，不处理
-                log.debug("rawType为非Class类型？打印出rawType：{}", rawType.getTypeName());
+            else {
-                return FieldTypeEnum.OTHER;
+                log.debug("泛型的主体情况不确定，不处理，打印出rawTypeClass：{}", rawTypeClass.getName());
+                return new ClassParseResult(FieldTypeEnum.OTHER, null);
             }
         }
 
         // 带T的参数，例如解析到ResponseData<T>中的data字段就是这种情况
+        // 这种情况，单纯从参数中是拿不到T的，需要从外部的参数中获取T的类型
         else if (type.getTypeName().equals("T")) {
-            return FieldTypeEnum.WITH_UNKNOWN_GENERIC;
+            return new ClassParseResult(FieldTypeEnum.WITH_UNKNOWN_GENERIC, null);
         }
 
         // 其他情况，既不是class也不是ParameterizedType
         else {
             log.debug("未知类型的处理，既不是class也不是ParameterizedType，打印出类的信息如下：{}", type.getTypeName());
-            return FieldTypeEnum.OTHER;
+            return new ClassParseResult(FieldTypeEnum.OTHER, null);
         }
     }