java泛型怎么用反射生成

泛型与反射的基础关联

Java泛型在编译期进行类型检查，运行时会被擦除为原始类型（如List擦除为List），这一特性使得泛型类型的运行时处理需要依赖反射，反射机制允许程序在运行时动态获取类的信息（如字段、方法、泛型参数等），并通过这些信息操作对象，两者结合时，反射能够突破泛型编译期的类型约束，实现动态创建泛型实例、获取泛型类型参数等操作，常用于框架开发（如Spring、MyBatis）中需要动态处理泛型类型的场景。

通过反射获取泛型类型信息

反射提供了多种API来获取泛型相关的类型信息，核心是Java类型系统中的Type接口及其子接口：ParameterizedType（参数化类型，如List）、TypeVariable（类型变量，如T）、GenericArrayType（泛型数组类型，如T[]）和WildcardType（通配符类型，如? extends Number）。

获取类或接口的泛型父类信息

通过Class对象的getGenericSuperclass()方法可获取直接父类的类型信息，若父类是泛型类，返回结果通常是ParameterizedType。

class Parent<T> {}  
class Child extends Parent<String> {}  
public class Main {  
    public static void main(String[] args) {  
        Type genericSuperclass = Child.class.getGenericSuperclass();  
        if (genericSuperclass instanceof ParameterizedType) {  
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;  
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();  
            System.out.println(actualTypeArguments[0].getTypeName()); // 输出: java.lang.String  
        }  
    }  
}  

获取接口的泛型参数

若类实现了泛型接口，可通过getGenericInterfaces()获取接口的泛型参数，用法与获取父类泛型类似。

获取方法返回值或参数的泛型类型

通过Method对象的getGenericReturnType()和getGenericParameterTypes()可获取方法返回值或参数的泛型类型。

public class GenericMethod {  
    public List<String> getStringList() { return new ArrayList<>(); }  
}  
public class Main {  
    public static void main(String[] args) throws Exception {  
        Method method = GenericMethod.class.getMethod("getStringList");  
        Type returnType = method.getGenericReturnType();  
        if (returnType instanceof ParameterizedType) {  
            ParameterizedType parameterizedType = (ParameterizedType) returnType;  
            Type[] typeArguments = parameterizedType.getActualTypeArguments();  
            System.out.println(typeArguments[0].getTypeName()); // 输出: java.lang.String  
        }  
    }  
}  

处理类型变量与通配符

TypeVariable用于表示类或方法中声明的类型变量（如类定义中的），可通过getTypeName()获取变量名，getBounds()获取其上界（如T extends Number），WildcardType则表示通配符（如? extends Number或? super String），可通过getUpperBounds()和getLowerBounds()获取上下界。

反射创建泛型实例的实践

反射创建泛型实例的核心是获取目标泛型类的Class对象，并通过Constructor实例化对象，由于泛型在运行时被擦除，直接创建泛型实例（如new ArrayList()）时，JVM实际处理的是ArrayList.class，因此需结合类型信息确保类型安全。

基本泛型类的实例化

对于无参构造的泛型类，可直接通过Class对象的newInstance()（已废弃，推荐使用getDeclaredConstructor().newInstance()）创建实例：

class Box<T> {  
    private T value;  
    public Box() {}  
    public T getValue() { return value; }  
    public void setValue(T value) { this.value = value; }  
}  
public class Main {  
    public static void main(String[] args) throws Exception {  
        Class<Box> boxClass = Box.class;  
        Box<String> box = boxClass.getDeclaredConstructor().newInstance();  
        box.setValue("Hello Reflection");  
        System.out.println(box.getValue()); // 输出: Hello Reflection  
    }  
}  

带参数构造的泛型类实例化

若泛型类有带参构造，需先获取对应的Constructor对象，并传入参数类型：

class Container<T> {  
    private T item;  
    public Container(T item) { this.item = item; }  
    public T getItem() { return item; }  
}  
public class Main {  
    public static void main(String[] args) throws Exception {  
        Class<Container> containerClass = Container.class;  
        Constructor<Container> constructor = containerClass.getDeclaredConstructor(String.class);  
        Container<Integer> container = constructor.newInstance(123);  
        System.out.println(container.getItem()); // 输出: 123  
    }  
}  

处理泛型类型参数的实例化（TypeToken方案）

直接通过反射创建泛型实例时，无法直接获取泛型参数的具体类型（如List中的String），为解决这一问题，可通过TypeToken机制（Google Guava提供）或匿名内部类捕获泛型类型信息：

import com.google.common.reflect.TypeToken;  
public class Main {  
    public static void main(String[] args) {  
        TypeToken<List<String>> stringListType = new TypeToken<List<String>>() {};  
        Type type = stringListType.getType();  
        System.out.println(type.getTypeName()); // 输出: java.util.List<java.lang.String>  
    }  
}  

通过TypeToken，可在运行时保留泛型参数信息，结合反射实现更复杂的泛型实例创建逻辑（如动态解析JSON并转换为泛型集合）。

泛型数组的反射处理

Java不允许直接创建泛型数组（如new List[]），但可通过反射绕过编译限制，需注意类型安全问题：

import java.lang.reflect.Array;  
public class Main {  
    public static void main(String[] args) {  
        // 创建List<String>[]数组（原始类型为List）  
        @SuppressWarnings("unchecked")  
        List<String>[] stringLists = (List<String>[]) Array.newInstance(List.class, 2);  
        stringLists[0] = new ArrayList<>();  
        stringLists[0].add("Hello");  
        System.out.println(stringLists[0].get(0)); // 输出: Hello  
    }  
}  

需注意，虽然反射可创建泛型数组，但操作时需避免类型不安全赋值（如将List存入stringLists），否则可能导致运行时异常。

使用反射处理泛型的注意事项

1. 类型擦除的限制：反射无法直接获取泛型的具体类型（如List中的String），需依赖ParameterizedType等接口间接获取。
2. 访问权限控制：若泛型类的构造函数或字段为private，需通过setAccessible(true)解除访问限制。
3. 性能影响：反射操作比直接调用慢，应避免在性能敏感场景频繁使用。
4. 类型安全：反射操作泛型时需确保类型匹配，避免因类型擦除导致的ClassCastException。
5. 第三方工具辅助：对于复杂泛型场景，可使用Guava的TypeToken或Spring的ResolvableType简化类型处理逻辑。

Java泛型与反射的结合为动态编程提供了强大支持，通过反射可获取泛型类型信息、创建泛型实例、处理泛型数组等操作，尽管类型擦除带来一定限制，但合理利用ParameterizedType、TypeToken等工具，可在框架开发、动态代理等场景中实现灵活的类型处理，开发者需注意类型安全和性能问题，在充分理解泛型与反射机制的基础上,高效运用这一技术组合。