各个方法1. 得到class的成员变量
首先得到object的class对象
然后在class对象中用getDeclaredFields()方法来获得class的成员变量
FieldTest ft = new FieldTest();Class ftClass = ft.getClass();Field[] fields = ftClass.getDeclaredFields();
2. field的函数
Field对象有很多成员方法
getName()获取名称。
getGenericType() 返回一个Type对象
getType() 返回Class对象
getGenericType 和getType区别:
返回类型一个是Class对象一个是Type接口。
如果属性是泛型，getType（）返回属性的接口类型。getGenericType（）还能返回参数类型。
String fieldName = field.getName();Type genericType = field.getGenericType();boolean isParameterizedType = (genericType instanceof ParameterizedType);Class fieldClazz = field.getType();String valueTypeName = genericType.getTypeName();
3.获取范型的Type和Class
获取 范型的key和value的Type
Type[] genericTypes = ((ParameterizedType) genericType).getActualTypeArguments();Type type0 = genericTypes[0];Type type1 = genericTypes[1];
通过google的com.google.common.reflect.TypeToken.of(type1).getRawType()方法获取map的key或者value的class类型。
Class<?> clazz = com.google.common.reflect.TypeToken.of(type1).getRawType();
总代码
class FieldTest { private String pri; protected String pro; public Map<Integer, HashMap<Integer, Float>> fcmap; public FieldTest() { } public FieldTest(String pri, String pro, String pub) { this.pri = pri; this.pro = pro; }}
package cn.hyperchain.hvm.abi;import java.lang.reflect.Array;import java.lang.reflect.Field;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.Arrays;import java.util.HashMap;import java.util.Map;public class Test { private static boolean checkClazzIsSpecific(Class CClazz, Class specific) { if (CClazz == specific) return true; Class[] interfaces = CClazz.getInterfaces(); boolean result = false; for (Class inter : interfaces) { if (result) break; if (inter == specific) { result = true; break; } result = checkClazzIsSpecific(inter, specific); } return result; } public static void main(String args[]) { FieldTest ft = new FieldTest(); Class ftClass = ft.getClass(); Field[] fields = ftClass.getDeclaredFields(); for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String fieldName = field.getName(); Type genericType = field.getGenericType(); Class fieldClass = field.getClass(); boolean isParameterizedType = (genericType instanceof ParameterizedType); Class fieldClazz = field.getType(); String valueTypeName = genericType.getTypeName(); System.out.println(); System.out.println("-------------------------------------------------"); System.out.println(); System.out.println("fieldName: " + fieldName); System.out.println("genericType: " + genericType); System.out.println("fieldClazz: " + fieldClazz); System.out.println("isParameterizedType: " + isParameterizedType); System.out.println("valueTypeName: " + valueTypeName); if (checkClazzIsSpecific(fieldClazz, Map.class)) { Type[] genericTypes = ((ParameterizedType) genericType).getActualTypeArguments(); Type type0 = genericTypes[0]; Type type1 = genericTypes[1]; String type1Name = genericTypes[1].getTypeName(); System.out.println("type0: " + type0); System.out.println("type1: " + type1); System.out.println("type1Name: " + type1Name); System.out.println(type1 instanceof ParameterizedType); Type type3 = ((ParameterizedType)type1).getOwnerType(); Class type4 = type1.getClass(); //Class<?> type5 = (Class<?>) type1; System.out.println("type3: " + type3); System.out.println("type4: " + type4); //System.out.println(type5); Class<?> clazz = com.google.common.reflect.TypeToken.of(type1).getRawType(); System.out.println("clazz: " + clazz); } } }}class FieldTest { private String pri; protected String pro;// public Map<String, Integer> map; public Map<Integer, HashMap<Integer, Float>> fcmap; public FieldTest() { } public FieldTest(String pri, String pro, String pub) { this.pri = pri; this.pro = pro; }}class abc { private String pri; protected String pro; public String pub; public String[] string; public int[] innt; public Map<String, Integer> map; public abc() { } public abc(String pri, String pro, String pub) { this.pri = pri; this.pro = pro; this.pub = pub; }}
结果：
————————————————-
fieldName: prigenericType: class java.lang.StringfieldClazz: class java.lang.StringisParameterizedType: falsevalueTypeName: java.lang.String
————————————————-
fieldName: progenericType: class java.lang.StringfieldClazz: class java.lang.StringisParameterizedType: falsevalueTypeName: java.lang.String
————————————————-
fieldName: fcmapgenericType: java.util.Map<java.lang.Integer, java.util.HashMap<java.lang.Integer, java.lang.Float>>fieldClazz: interface java.util.MapisParameterizedType: truevalueTypeName: java.util.Map<java.lang.Integer, java.util.HashMap<java.lang.Integer, java.lang.Float>>type0: class java.lang.Integertype1: java.util.HashMap<java.lang.Integer, java.lang.Float>type1Name: java.util.HashMap<java.lang.Integer, java.lang.Float>truetype3: nulltype4: class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImplclazz: class java.util.HashMap
Process finished with exit code 0
补充：Java-使用反射获取类型信息
Java中如何使用反射获取类型信息？
最近写了大量需要根据类属性的类型反射注入值的代码，总结了以下常用的反射技巧：
一个简单类的例子
在这个类中，有普通的String类型，有数组类型，有带泛型的List类型，有嵌套List类型，以及有多个泛型参数的简单类，这个类将作为我们后面的内容的基础。我们这一次博客解析如何使用反射获取到不同属性的类型值。
public class Some{ private String name; private Integer[] numbers; private List<String> list; private List<List<Double>> matrix; private Map<String,Class> map; //ignore getter and setter}
分析如何获取不同属性的类型1、普通类型
普通类型的变量直接field.getType()即可以获取到他们的类型
public void queryNameType() throws NoSuchFieldException { Field field = Some.class.getDeclaredField("name"); Class<?> type = field.getType(); assertEquals(type,String.class);}
2、数组类型
数组类型不像其他的类型可以通过isAssignableFrom()函数来进行判断，他需要使用isArray() 来判断该type是否是一个数组类型，然后使用getComponentType() 获取他的元素的类型
public void queryArrayType() throws NoSuchFieldException { Field field = Some.class.getDeclaredField("numbers"); Class<?> type = field.getType(); //一般来说，判断是否是某种类型是可以使用isAssignableFrom // 判断是否是数组类型比较特殊，要使用isArray()这个函数 if (type.isArray()){ //获得数组的类型，使用getComponentType()这个方法 Class<?> componentType = type.getComponentType(); assertEquals(componentType,Integer.class); } else{ throw new IllegalStateException(); }}
3、带泛型的类型
带泛型的类型就是类似于List<String>这样的类型，我们现在的任务就是获取到String这个类型。
ParameterizedType表示参数化的类型，例如Collection这样的类型。我们可以通过getGenericType()方法获得该子类，当你的类型带有参数的时候就会返回ParameterizedType,否则会返回普通的类型(class)
那么具体是怎么操作的呢？
以获得List<T>的类型为例子
public void getListType() throws NoSuchFieldException { Field field = Some.class.getDeclaredField("list"); //如果类似于List<String>这样的类型就是一种GenericType //注意这是一种Type类型 Type type = field.getGenericType(); if (type instanceof ParameterizedType){ //泛型参数类型 ParameterizedType parameterizedType = (ParameterizedType)type; Type[] actualTypes = parameterizedType.getActualTypeArguments(); //因为List<String>获得第一个泛型参数,因为只有一个，我们取第一个 //如果我们有多个泛型参数，我们可以根据顺序取不同的泛型参数 assertEquals(actualTypes[0],String.class); //如果获得List这个原始类型呢？ assertEquals(parameterizedType.getRawType(),List.class); }else{ throw new IllegalStateException(); }}
4、复杂的嵌套类型
假如是List<List<String>> 如何获得最里面的类型呢？
例子如下
public void getSubListType() throws NoSuchFieldException { //思考一下，如果我们有一个嵌套List，我们想拿到嵌套在最里面的类型，那么我们可以这么做呢？ //其实我们可以使用递归的思想去获得最里面的类型 Field field = Some.class.getDeclaredField("matrix"); assertEquals(getBaseType(field.getGenericType()),Double.class); } public static Type getBaseType(Type genericReturnType){ Objects.requireNonNull(genericReturnType); if (genericReturnType instanceof ParameterizedType && List.class.isAssignableFrom((Class)(((ParameterizedType) genericReturnType).getRawType()))){ Type[] actualTypeArguments = ((ParameterizedType)genericReturnType).getActualTypeArguments(); Type type = actualTypeArguments[0]; return getBaseType(type); }else{ return genericReturnType; } }
5、多个泛型参数
与第三个例子相似，只需要使用actualTypes数组按顺序取即可
例子如下
public void getMapType() throws NoSuchFieldException { Field field = Some.class.getDeclaredField("map"); Type type = field.getGenericType(); if (type instanceof ParameterizedType){ ParameterizedType parameterizedType = (ParameterizedType)type; Type[] actualTypes = parameterizedType.getActualTypeArguments(); assertEquals(actualTypes[0],String.class); assertEquals(actualTypes[1],Class.class); }else{ throw new IllegalStateException(); }}
总结
以上总结了几种常用的使用反射获取属性类型的例子，稍加改造就可以写自己的工具类了。希望对大家有帮助^_^
对于旅行，从来都记忆模糊。记不得都去了哪些地方，
