diff --git a/kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/pojo/clazz/ClassParseResult.java b/kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/pojo/clazz/ClassParseResult.java index 633fc5416..1c5d5b08e 100644 --- a/kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/pojo/clazz/ClassParseResult.java +++ b/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 { /** diff --git a/kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/util/ClassTypeUtil.java b/kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/util/ClassTypeUtil.java index 20bcaa54a..5fd30048a 100644 --- a/kernel-a-rule/src/main/java/cn/stylefeng/roses/kernel/rule/util/ClassTypeUtil.java +++ b/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类型解析 + *

+ * 返回的类型更简单，但是携带的信息更丰富一些，带具体的泛型的类型 * * @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 FieldTypeEnum.BASE_ARRAY; - } else { - return FieldTypeEnum.ARRAY_WITH_OBJECT; - } + return new ClassParseResult(FieldTypeEnum.ARRAY, componentType); } // 如果是集合类型，纯集合类型，不带泛型 else if (Collection.class.isAssignableFrom(clazz)) { - return FieldTypeEnum.BASE_COLLECTION; + return new ClassParseResult(FieldTypeEnum.COLLECTION, null); } // 如果是Object类型，则认定为基本类型，不解析他的具体内容 - else if (Object.class.equals(clazz)) { - return FieldTypeEnum.BASIC; + // 【注意】如果是解析具体实体类型，用AdvancedClassTypeUtil类 + 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; - // 泛型类的主体 - Type rawType = parameterizedType.getRawType(); + // 泛型的主体，例如 List，主体是List + Class rawTypeClass = (Class) parameterizedType.getRawType(); - if (rawType instanceof Class) { - Class rawTypeClass = (Class) rawType; + // 泛型的类型，例如 List，类型是String + Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0]; - // 如果泛型主体是集合 - if (Collection.class.isAssignableFrom(rawTypeClass)) { - return FieldTypeEnum.COLLECTION_WITH_OBJECT; - } + // 如果泛型主体是集合 + if (Collection.class.isAssignableFrom(rawTypeClass)) { + return new ClassParseResult(FieldTypeEnum.COLLECTION, actualTypeArgument); + } - // 如果是map类型，则认定为基本类型，不做处理，不解析他的元数据 - else if (Map.class.isAssignableFrom(rawTypeClass)) { - return FieldTypeEnum.BASIC; - } + // 如果是map类型，则认定为基本类型，不做处理，不解析他的元数据 + else if (Map.class.isAssignableFrom(rawTypeClass)) { + return new ClassParseResult(FieldTypeEnum.BASIC, null); + } - // 泛型的主体情况不确定，不处理 - else { - log.debug("泛型的主体情况不确定，不处理，打印出rawTypeClass：{}", rawTypeClass.getName()); - return FieldTypeEnum.OTHER; - } - } else { - // 泛型的主体是别的类型 - log.debug("rawType为非Class类型？打印出rawType：{}", rawType.getTypeName()); - return FieldTypeEnum.OTHER; + // 如果是Object类型，则认定为基本类型，不解析他的具体内容 + // 【注意】如果是解析具体实体类型，用AdvancedClassTypeUtil类 + else if (Object.class.isAssignableFrom(rawTypeClass)) { + return new ClassParseResult(FieldTypeEnum.OBJECT_WITH_GENERIC, actualTypeArgument); + } + + // 泛型的主体情况不确定，不处理 + else { + log.debug("泛型的主体情况不确定，不处理，打印出rawTypeClass：{}", rawTypeClass.getName()); + return new ClassParseResult(FieldTypeEnum.OTHER, null); } } // 带T的参数，例如解析到ResponseData中的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); } }