直播平台网站建设,成都网站建设服务有什么,wordpress改固定连接,网站备案的幕布是什么来的解析泛型类型
获取字段泛型类型
**java.lang.reflect.Field#getGenericType**: 作用#xff1a;返回字段的泛型类型。返回类型#xff1a;Type。如果字段是一个泛型类型#xff0c;这个方法将返回一个表示这个泛型类型的 Type 对象#xff0c;比如 ParameterizedType返回字段的泛型类型。返回类型Type。如果字段是一个泛型类型这个方法将返回一个表示这个泛型类型的 Type 对象比如 ParameterizedTypeTypeVariable 等等。如果字段不是泛型类型这个方法将返回字段的具体类型即 Class 对象。示例
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;public class MyClassK, V {private K key;private V value;private ListString list;public static void main(String[] args) throws Exception {Field field MyClass.class.getDeclaredField(list);Type fieldType field.getGenericType();System.out.println(fieldType : class fieldType.getClass());if (fieldType instanceof ParameterizedType) {ParameterizedType parameterizedType (ParameterizedType) fieldType;System.out.println(ActualType: parameterizedType.getActualTypeArguments()[0]);}}
}输出结果
java.util.Listjava.lang.String: class class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
ActualType: class java.lang.String获取对象泛型类型
**java.lang.Class#getTypeParameters**: 作用返回类或接口的类型参数。返回类型TypeVariable?[]。如果类或接口没有定义类型参数这个方法将返回一个空数组。如果类或接口有类型参数这个方法将返回这些类型参数的数组。示例
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.List;public class MyClassK, V {private K key;private V value;private ListString list;public static void main(String[] args) throws Exception {TypeVariable?[] typeParameters MyClass.class.getTypeParameters();for (TypeVariable? typeParameter : typeParameters) {System.out.println(typeParameter.getName() : class typeParameter.getClass());System.out.println(Bounds:);for (Type bound : typeParameter.getBounds()) {System.out.println(bound);}}}
}输出结果此处的范型被擦除了后续会讲解具体的解决方案
K: classclass sun.reflect.generics.reflectiveObjects.TypeVariableImpl
Bounds:
class java.lang.Object
V: classclass sun.reflect.generics.reflectiveObjects.TypeVariableImpl
Bounds:
class java.lang.Object总结
Field#getGenericType 是针对类的字段返回字段的泛型类型或具体类型。Class#getTypeParameters 是针对类或接口返回定义在类或接口上的类型参数。
如果你想获取一个类中字段的实际类型Field#getGenericType 是合适的方法。如果你想获取类本身定义的类型参数Class#getTypeParameters 是正确的方法。
ParameterizedType与TypeVariable区别
ParameterizedType 和 TypeVariable 是 Java 反射 API 中的两个接口用于表示不同类型的泛型类型信息。它们之间的区别在于它们表示的泛型类型的不同方面。
ParameterizedType
ParameterizedType 表示的是一个参数化的类型即使用具体类型参数化的泛型类型。它包含了泛型类型的完整信息包括原始类型和实际类型参数。例如对于 ListStringParameterizedType 会表示 ListString 这个具体的类型。
主要方法
Type[] getActualTypeArguments()返回实际的类型参数数组。Type getRawType()返回原始类型即未参数化的类型例如 List。Type getOwnerType()返回拥有者类型如果类型是一个内部类这个方法返回其外部类否则返回 null。
示例
import java.lang.reflect.*;public class ParameterizedTypeExample {public static void main(String[] args) throws NoSuchFieldException {Field field MyClass.class.getDeclaredField(list);Type type field.getGenericType();if (type instanceof ParameterizedType) {ParameterizedType parameterizedType (ParameterizedType) type;System.out.println(Raw type: parameterizedType.getRawType());System.out.println(Actual type arguments:);for (Type actualTypeArgument : parameterizedType.getActualTypeArguments()) {System.out.println(actualTypeArgument);}}}static class MyClass {ListString list;}
}输出结果
Raw type: interface java.util.List
Actual type arguments:
class java.lang.StringTypeVariable
TypeVariable 表示的是一个类型变量泛型类型参数通常在泛型类、接口或方法的定义中使用。例如对于 T 在 class MyClassT 中TypeVariable 就表示 T。
主要方法
Type[] getBounds()返回类型变量的上边界可能有多个默认为 Object。D getGenericDeclaration()返回声明这个类型变量的泛型声明通常是 Class、Method 或 Constructor。String getName()返回类型变量的名称。
示例
import java.lang.reflect.*;public class TypeVariableExample {public static void main(String[] args) {TypeVariableClassMyClass[] typeParameters MyClass.class.getTypeParameters();for (TypeVariableClassMyClass typeParameter : typeParameters) {System.out.println(Name: typeParameter.getName());System.out.println(Bounds:);for (Type bound : typeParameter.getBounds()) {System.out.println(bound);}}}static class MyClassT extends Number {T value;}
}输出结果
Name: T
Bounds:
class java.lang.Number区别总结
**ParameterizedType** 表示的是已经用实际类型参数化的泛型类型。例如ListString 是一个 ParameterizedType。**TypeVariable** 表示的是泛型类型参数本身。例如T 在 class MyClassT 中是一个 TypeVariable。
这两个接口的主要区别在于它们表示的类型信息的不同ParameterizedType 表示完整的参数化类型而 TypeVariable 表示泛型类型参数。
泛型擦除
有时候为了扩展需要动态的根据泛型获取对应的处理类此时涉及到类型擦除时需要强制转换支持
ListPipeline?, MyOutput无法直接强转为ListPipelineT, MyOutput
解决方法
(List?)将ListPipeline?, MyOutput中的类型擦除然后再次强转为ListPipelineT, MyOutput遍历列表将元素强转为目标类型之后添加到列表
private static final MapObject, ListPipeline?, MyOutput PIPELINE Maps.newHashMap();SuppressWarnings(unchecked)
public T ListPipelineT, MyOutput get(T input) {return (ListPipelineT, MyOutput) (List?) PIPELINE.get(input);
}SuppressWarnings(unchecked)
public T ListPipelineT, MyOutput getCanBuyPipeLine(T input) {ListPipelineT, MyOutput result Lists.newArrayList();for (Pipeline?, MyOutput pipeline : PIPELINE.get(input)) {result.add((PipelineT, MyOutput) pipeline);}return result;
}第一种方式
GenericTypeDemoInteger demo new GenericTypeDemo();
Type t new TypeTokenT(demo.getClass()) {}.getType();创建实例
GenericTypeDemoInteger demo new GenericTypeDemo();创建了一个 GenericTypeDemoInteger 的实例。
使用 TypeToken 获取类型
Type t new TypeTokenT(demo.getClass()) {}.getType();这段代码试图通过 TypeToken 获取 demo 的泛型类型。这里的 TypeTokenT 依赖于 demo.getClass()但是 demo.getClass() 返回的是 GenericTypeDemo 的运行时类信息其中的泛型类型已经被擦除。因此TypeTokenT 无法捕获到实际的泛型类型 Integer。
第二种方式
import com.google.common.reflect.TypeToken;public class GenericTypeDemoT {private final TypeTokenT typeToken;public GenericTypeDemo() {this.typeToken new TypeTokenT(getClass()) {};}public TypeTokenT getTypeToken() {return this.typeToken;}public static void main(String[] args) {GenericTypeDemoInteger demo new GenericTypeDemo() {};System.out.println(泛型类型是: demo.getTypeToken().getType());}
}定义类和构造函数
public class GenericTypeDemoT {private final TypeTokenT typeToken;public GenericTypeDemo() {this.typeToken new TypeTokenT(getClass()) {};}public TypeTokenT getTypeToken() {return this.typeToken;}
}在这个类中TypeTokenT 被用来捕获 GenericTypeDemo 的泛型类型。关键在于 new TypeTokenT(getClass()) {}这是在匿名子类中使用 TypeToken 捕获泛型类型信息。
使用泛型类型实例化对象
public static void main(String[] args) {GenericTypeDemoInteger demo new GenericTypeDemo() {};System.out.println(泛型类型是: demo.getTypeToken().getType());
}在 main 方法中GenericTypeDemoInteger 被实例化为匿名子类因此 TypeToken 可以捕获到实际的泛型类型 Integer。当调用 demo.getTypeToken().getType() 时会正确输出 Integer 的类型。
总结
第一种方式 直接通过 demo.getClass() 获取类型类型信息在运行时已经被擦除TypeTokenT 无法获取到实际的泛型类型。最终得到的 Type t 只是一个原始的类型 GenericTypeDemo没有泛型信息。 第二种方式 在 GenericTypeDemo 类的构造函数中通过匿名子类和 TypeTokenT 捕获泛型类型信息。实例化 GenericTypeDemoInteger 时匿名子类保留了泛型类型信息TypeTokenT 成功捕获到实际的泛型类型 Integer。结果是 demo.getTypeToken().getType() 能够正确输出泛型类型 Integer。
因此第二种方式能够正确捕获和输出泛型类型信息而第一种方式由于泛型类型擦除问题无法正确捕获泛型类型。
spring中获取泛型
抽象类与泛型捕获
假设我们有一个抽象类 AbstractComponent
import com.google.common.reflect.TypeToken;public abstract class AbstractComponentT {private final ClassT type (ClassT) new TypeTokenT(getClass()) {}.getType();public AbstractComponent() {}public ClassT getType() {return this.type;}
}关键点
**TypeToken**** 的使用**
new TypeTokenT(getClass()) {}- TypeToken 是 Guava 库中的一个工具类它用于在运行时捕获和处理泛型类型信息。
- TypeToken 的构造函数接收一个 Class 对象这里是 getClass()它在这个上下文中返回 AbstractComponent 的运行时类。为什么能够捕获泛型类型 在 AbstractComponentT 类中getClass() 返回的是 AbstractComponent 的运行时类而不是具体的子类。当创建具体子类例如 ConcreteComponent时AbstractComponent 的构造函数会执行并且 TypeToken 实例会使用当前运行时类即 ConcreteComponent来初始化。 类型擦除与泛型捕获 类型擦除Java 的泛型在编译时会进行类型擦除这意味着在运行时泛型类型 T 的具体信息会丢失。但在创建子类时匿名子类的 TypeToken 实例会捕获并保留泛型类型信息。具体子类的影响当具体子类例如 ConcreteComponent被实例化时它会调用父类的构造函数。在这种情况下TypeToken 能够通过匿名子类的方式捕获实际的泛型类型。
示例
假设我们有以下具体子类
import org.springframework.stereotype.Component;Component
public class ConcreteComponent extends AbstractComponentString {// Concrete implementation
}执行流程
创建子类实例
ConcreteComponent component new ConcreteComponent();- 这会调用 ConcreteComponent 的构造函数而 ConcreteComponent 的构造函数会调用 AbstractComponent 的构造函数。**AbstractComponent**** 的构造函数**
public AbstractComponent() {// Initializer of the final field type
}- 在这个构造函数中TypeToken 实例使用 getClass() 返回 ConcreteComponent 的运行时类。这是由于在 AbstractComponent 的 type 字段初始化时new TypeTokenT(getClass()) {} 被调用。捕获泛型类型 new TypeTokenT(getClass()) {} 创建了一个匿名子类并且这个匿名子类通过反射机制获取到了泛型类型 String。因此type 字段被正确初始化为 String 的 Class 对象。
总结
运行时类信息在 AbstractComponent 中通过 getClass() 返回具体子类如 ConcreteComponent的运行时类信息。匿名子类和泛型捕获TypeToken 的匿名子类能够在创建时捕获并保留泛型类型信息即使在运行时泛型信息被擦除。实例化时的行为当具体子类被实例化时它会调用父类的构造函数TypeToken 实例通过具体子类的运行时类信息正确捕获泛型类型。
因此在你的抽象类 AbstractComponentT 中final 字段 type 能够正确保存具体泛型类型信息是因为匿名子类机制允许 TypeToken 捕获到实际的泛型类型 T。
spring能够获取到泛型是因为spring使用了代理超类bean对于spring来说是子类化了所以可以通过反射或者TypeToken方式获取到具体的泛型
Spring 能够获取到泛型类型信息主要是因为它在处理 bean 时会使用一些技巧来保持泛型的类型信息。具体来说
代理超类Spring 在创建代理对象时通常会使用自定义的代理超类这样可以在运行时通过反射获取到泛型参数的信息。TypeTokenSpring 通过使用 TypeToken类似于 Google Guava 的 TypeToken 类来保持泛型信息。在类型擦除的情况下TypeToken 提供了一个获取具体泛型类型的方法。反射Spring 使用反射机制来获取泛型参数的类型信息。例如Spring 的 Autowired 注解可以自动注入泛型类型的 BeanSpring 在进行注入时会解析泛型参数的信息。自定义 Bean 实现在一些情况下Spring 可能会使用自定义的 Bean 实现来保持泛型类型信息。这种方法通常是通过在 Bean 定义中显式声明泛型类型。
总之Spring 通过这些机制确保了泛型类型信息可以在运行时被正确地获取和使用。
普通对象获取泛型
new Pipeline() 创建实例时Java 的类型擦除特性会导致你无法直接获取泛型的具体类型。类型擦除是指在编译时Java 泛型信息会被移除导致在运行时无法直接获取泛型参数的实际类型。
Spring 在处理泛型时能够获取到泛型类型参数是因为 Spring 在实例化 bean 的时候通常使用了代理或其他机制来保存泛型信息。以下是一些解决方法可以帮助你获取泛型参数的实际类型
使用 TypeToken 获取泛型类型
你可以使用 TypeTokenGuava 库中的一个工具类来获取泛型类型信息但要注意TypeToken 需要在 Pipeline 子类中使用才能正确地获得泛型类型。示例如下
import com.google.common.reflect.TypeToken;public class PipelineI, O {private final ClassI inputClass;SuppressWarnings(unchecked)public Pipeline() {TypeTokenPipelineI, O typeToken new TypeTokenPipelineI, O(getClass()) {};this.inputClass (ClassI) typeToken.resolveType(typeToken.getType().getActualTypeArguments()[0]).getRawType();}public ClassI getInputClass() {return inputClass;}// Other methods...
}使用反射获取泛型类型
如果你不想使用 Guava 库你可以在 Pipeline 的子类中获取泛型类型信息。示例如下
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;public class PipelineI, O {private final ClassI inputClass;SuppressWarnings(unchecked)public Pipeline() {this.inputClass (ClassI) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];}public ClassI getInputClass() {return inputClass;}// Other methods...
}确保子类化 Pipeline
确保 Pipeline 是通过子类化的方式实例化的这样可以保留泛型信息。例如
public class StringPipeline extends PipelineString, Integer {// Implementation details...
}在 StringPipeline 中你可以通过反射或者 TypeToken 来获取 String 类型信息。
结论
Java 的类型擦除特性使得泛型类型信息在运行时不可用。使用 TypeToken 或者在子类中通过反射获取泛型类型是解决这个问题的常用方法。如果你使用 Spring 或其他框架它们通常会在创建 bean 时保留泛型信息这样你可以在运行时访问这些信息。
