gitee
/
roses
mirror of https://gitee.com/stylefeng/roses
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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

pull/62/head
stylefeng 2024-08-07 16:41:14 +08:00
parent d5b43c3134
commit 6c533b4c6e
5 changed files with 63 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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>

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

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

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

@ -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

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

@ -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. 获取这个字段的类型，也就是泛型对象的泛型
Type subFieldType = classParseResult.getGenericType();
// 3. 继续进行这个字段的解析，判断是否需要填充子字段或者数组字段
ClassMetaFactory.getSubFieldTypeAndFillOriginMeta(uuid, subField, subFieldType);
// 2. 如果是List<T>也一样，需要从这里获取泛型的具体类型
if (FieldTypeEnum.WITH_UNKNOWN_ARRAY_GENERIC.getCode().equals(subField.getFieldType())) {
Type arrayRealGenericType = classParseResult.getGenericType();
ClassMetaFactory.getGenericListFieldTypeAndFillOriginMeta(uuid, subField, arrayRealGenericType);
}
}
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());
}
}

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

@ -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