jdk中的java.lang.reflect.Type说明

不念不忘少年蓝@ 2023-01-13 09:34 135阅读 0赞

## 1：说明 ##

反射相关，主要是用于描述泛型，方法参数，数组等的参数的类型的，比如获取`HashMap<String,Integer>`中`HashMap`,以及`<String,Integer>`,先来看下java.lang.reflect.Type的源码：

public interface Type { 
        
        default String getTypeName() { 
            return toString();
        }
    }

## 2：ParameterizedType ##

该接口用来获取带有泛型的变量的类型信息，继承自`java.lang.reflect.Type`。

### 2.1：getRawType和getActualTypeArguments ###

这两个方法作用如下：

getRawType：获取变量的类型
    getActualTypeArguments：获取泛型的参数的类型信息

`java.lang.reflect.Type`接口有一个子接口`java.lang.reflect.ParameterizedType`，主要是用来描述泛型的类型信息，比如`HashMap<String, Integer>`，我们可以通过方法`getRawType`获取`HashMap`，通过方法`getActualTypeArguments`获取`<String, Integer>`，下面来看个例子：

public class TestParameterizedTypeBean { 
    
       public static void main(String[] args) { 
           testMapGenericType();
       }
       private HashMap<String, Integer> myMap;
       private static void testMapGenericType() { 
           try { 
               // 获取变量HashMap<String, Integer> myMap中的<String, Integer>
               Field myMapField = TestParameterizedTypeBean.class.getDeclaredField("myMap");
               // 获取字段的类型
               Type myMapType = myMapField.getGenericType();
               // 获取带有全限定名称的类型名称java.util.HashMap<java.lang.String, java.lang.Integer>
               System.out.println(myMapType.getTypeName());
               // 强转,继承关系为ParameterizedTypeImpl--->java.lang.reflect.ParameterizedType--->java.lang.Type
               ParameterizedTypeImpl parameterizedMyMapType
                       = (ParameterizedTypeImpl)myMapType;
               Type[] actualTypeArguments = parameterizedMyMapType.getActualTypeArguments();
               System.out.println("获取<String, Integer>实际的参数类型开始");
               for (Type actualTypeArgument : actualTypeArguments) { 
                   System.out.println(actualTypeArgument);
               }
               System.out.println("获取<String, Integer>实际的参数类型结束");
               System.out.println("获取HashMap实际类型开始");
               System.out.println(parameterizedMyMapType.getRawType());
               System.out.println("获取HashMap实际类型结束");
           } catch (Exception e) { }
       }
    }

运行：

java.util.HashMap<java.lang.String, java.lang.Integer>
    获取<String, Integer>实际的参数类型开始
    class java.lang.String
    class java.lang.Integer
    获取<String, Integer>实际的参数类型结束
    获取HashMap实际类型开始
    class java.util.HashMap
    获取HashMap实际类型结束

### 2.2：getOwnerType() ###

该方法用户获取类型所在类的类型，例如ParameterizedType类型是Map.Entry<String,Integer>,则结果就是`java.util.Map`，如下例子：

public class TestParameterizedTypeBean { 
    
       public static void main(String[] args) { 
           testOwnerTypeMap();
       }
       private Map.Entry<String, Integer> ownerTypeMapEntry;
    
       private static void testOwnerTypeMap() { 
           try { 
               // 获取对应的字段对象
               Field ownerTypeMapField
                       = TestParameterizedTypeBean.class.getDeclaredField("ownerTypeMapEntry");
               // 从字段中获取对应的类型信息对象
               ParameterizedTypeImpl ownerTypeMapType = (ParameterizedTypeImpl)ownerTypeMapField.getGenericType();
               // 类型是java.lang.Class，这也是java.lang.reflect.Type的子类，定义如下：
               // public final class Class<T> implements java.io.Serializable,
               // GenericDeclaration,
               // Type,
               // AnnotatedElement {}
               java.lang.Class ownerType = (java.lang.Class)ownerTypeMapType.getOwnerType();
               System.out.println("owner type is: ");
               System.out.println(ownerType);
           } catch (Exception e) { }
       }
    }

运行：

owner type is: 
    interface java.util.Map

## 3：TypedVariable ##

我们知道，jvm编译后，为了兼容老版本的jdk，会执行反省擦除操作，此时，不会存留有任何泛型的痕迹，那么如果我们想要获取泛型的原始的定义信息，怎么办呢？就可以使用TypedVariable。如下实例：

public class TypedVariableTest<A extends Number, B extends Serializable, C, D> { 
        public static void main(String[] args) { 
            TypeVariable<Class<TypedVariableTest>>[] typeParameters
                    = TypedVariableTest.class.getTypeParameters();
            System.out.println("打印泛型的原始名称开始。。。");
            for (TypeVariable<Class<TypedVariableTest>> typeParameter : typeParameters) { 
                String name = typeParameter.getName();
                System.out.println(name);
            }
            System.out.println("打印泛型的原始名称结束。。。");
            System.out.println("打印泛型上限类型开始。。。");
            for (TypeVariable<Class<TypedVariableTest>> typeParameter : typeParameters) { 
                Type boundType = typeParameter.getBounds()[0];
                System.out.println(boundType);
            }
            System.out.println("打印泛型上限类型结束。。。");
            System.out.println("打印所在类开始。。。");
            for (TypeVariable<Class<TypedVariableTest>> typeParameter : typeParameters) { 
                Type genericType = typeParameter.getGenericDeclaration();
                System.out.println(genericType);
            }
            System.out.println("打印所在类结束。。。");
        }
    }

测试：

打印泛型的原始名称开始。。。
    A
    B
    C
    D
    打印泛型的原始名称结束。。。
    打印泛型上限类型开始。。。
    class java.lang.Number
    interface java.io.Serializable
    class java.lang.Object
    class java.lang.Object
    打印泛型上限类型结束。。。
    打印所在类开始。。。
    class yudaosourcecode.hashcodeandequals.TypedVariableTest
    class yudaosourcecode.hashcodeandequals.TypedVariableTest
    class yudaosourcecode.hashcodeandequals.TypedVariableTest
    class yudaosourcecode.hashcodeandequals.TypedVariableTest
    打印所在类结束。。。

## 4：GenericArrayType ##

用于获取`泛型数组`的相关的类型信息，继承自`java.lang.relect.Type`，看例子：

public class GenericArrayTypeTest<T> { 
        private T[] tArr;
        private List<Integer>[] listIntegerArr;
        private Set<T>[] setTArr;
    
        public static void main(String[] args) { 
            Field[] declaredFields = GenericArrayTypeTest.class.getDeclaredFields();
            System.out.println("获取参数的名称开始。。。");
            for (Field declaredField : declaredFields) { 
                System.out.println(declaredField.getName());
            }
            System.out.println("获取参数的名称结束。。。");
            System.out.println("获取数组中数据类型开始。。。");
            for (Field declaredField : declaredFields) { 
                GenericArrayType genericType = (GenericArrayType)declaredField.getGenericType();
                System.out.println(genericType.getGenericComponentType());
            }
            System.out.println("获取数组中数据类型结束。。。");
        }
    }

运行：

获取参数的名称开始。。。
    tArr
    listIntegerArr
    setTArr
    获取参数的名称结束。。。
    获取数组中数据类型开始。。。
    T
    java.util.List<java.lang.Integer>
    java.util.Set<T>
    获取数组中数据类型结束。。。

## 5：WildcardType ##

用来描述方法中使用了`?`通配符的泛型参数的类型，可以通过方法`getUppderBounds`获取上限类型，通过方法`getLowerBounds`获取下限类型，如下测试代码：

public class MyWildcardTypeTest { 
        private void myWildcardFn(List<?> questionMarkList,
                                  Set<? extends Number> questionMarkExtendNumberSet, Collection<? super Queue> questionMarkSuperCollection
        ) { }
    
        public static void main(String[] args) { 
            Method[] declaredMethods = MyWildcardTypeTest.class.getDeclaredMethods();
            for (Method declaredMethod : declaredMethods) { 
                // 过滤main函数
                if ("main".equals(declaredMethod.getName())) continue;
                // 获取方法中的所有参数对应的参数类型数组
                Type[] genericReturnTypeArr = declaredMethod.getGenericParameterTypes();
                // 处理每一个参数
                for (int i = 0; i < genericReturnTypeArr.length; i++) { 
                    Type genericReturnType = genericReturnTypeArr[i];
                    // 强转ParameterizedTypeImpl
                    ParameterizedTypeImpl parameterizedTypeType
                            = (ParameterizedTypeImpl)genericReturnType;
                    System.out.println("变量信息是："
                            + parameterizedTypeType.getTypeName());
                    // 获取封装有通配符信息的类型对象WildcardType
                    Type[] actualTypeArguments = parameterizedTypeType.getActualTypeArguments();
                    WildcardType actualTypeArgument = (WildcardType)actualTypeArguments[0];
                    // 获取上限类型
                    System.out.println("上限类型是：" + actualTypeArgument.getUpperBounds()[0]);
                    // 获取下限类型
                    if (actualTypeArgument.getLowerBounds().length > 0) { 
                        System.out.println("下限类型是：" + actualTypeArgument.getLowerBounds()[0]);
                    } else { 
                        System.out.println("无下限类型");
                    }
                }
            }
        }
    }

运行：

变量信息是：java.util.List<?>
    上限类型是：class java.lang.Object
    无下限类型
    变量信息是：java.util.Set<? extends java.lang.Number>
    上限类型是：class java.lang.Number
    无下限类型
    变量信息是：java.util.Collection<? super java.util.Queue>
    上限类型是：class java.lang.Object
    下限类型是：interface java.util.Queue