Java 反射類(lèi)型Type的用法說(shuō)明

各個(gè)方法

1. 得到class的成員變量

首先得到object的class對象

然后在class對象中用getDeclaredFields()方法來(lái)獲得class的成員變量

FieldTest ft = new FieldTest();
Class ftClass = ft.getClass();
Field[] fields = ftClass.getDeclaredFields();

2. field的函數

Field對象有很多成員方法

getName()獲取名稱(chēng)。

getGenericType() 返回一個(gè)Type對象

getType() 返回Class對象

getGenericType 和getType區別:

返回類(lèi)型一個(gè)是Class對象一個(gè)是Type接口。

如果屬性是泛型，getType（）返回屬性的接口類(lèi)型。getGenericType（）還能返回參數類(lèi)型。

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];

通過(guò)google的com.google.common.reflect.TypeToken.of(type1).getRawType()方法獲取map的key或者value的class類(lèi)型。

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: pri
genericType: class java.lang.String
fieldClazz: class java.lang.String
isParameterizedType: false
valueTypeName: java.lang.String

-------------------------------------------------

fieldName: pro
genericType: class java.lang.String
fieldClazz: class java.lang.String
isParameterizedType: false
valueTypeName: java.lang.String

-------------------------------------------------

fieldName: fcmap
genericType: java.util.Map<java.lang.Integer, java.util.HashMap<java.lang.Integer, java.lang.Float>>
fieldClazz: interface java.util.Map
isParameterizedType: true
valueTypeName: java.util.Map<java.lang.Integer, java.util.HashMap<java.lang.Integer, java.lang.Float>>
type0: class java.lang.Integer
type1: java.util.HashMap<java.lang.Integer, java.lang.Float>
type1Name: java.util.HashMap<java.lang.Integer, java.lang.Float>
true
type3: null
type4: class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
clazz: class java.util.HashMap

Process finished with exit code 0

補充：Java-使用反射獲取類(lèi)型信息

Java中如何使用反射獲取類(lèi)型信息？

最近寫(xiě)了大量需要根據類(lèi)屬性的類(lèi)型反射注入值的代碼，總結了以下常用的反射技巧：

一個(gè)簡(jiǎn)單類(lèi)的例子

在這個(gè)類(lèi)中，有普通的String類(lèi)型，有數組類(lèi)型，有帶泛型的List類(lèi)型，有嵌套List類(lèi)型，以及有多個(gè)泛型參數的簡(jiǎn)單類(lèi)，這個(gè)類(lèi)將作為我們后面的內容的基礎。我們這一次博客解析如何使用反射獲取到不同屬性的類(lèi)型值。

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
}

分析如何獲取不同屬性的類(lèi)型

1、普通類(lèi)型

普通類(lèi)型的變量直接field.getType()即可以獲取到他們的類(lèi)型

public void queryNameType() throws NoSuchFieldException {
    Field field = Some.class.getDeclaredField("name");
    Class<?> type = field.getType();
    assertEquals(type,String.class);
}

2、數組類(lèi)型

數組類(lèi)型不像其他的類(lèi)型可以通過(guò)isAssignableFrom()函數來(lái)進(jìn)行判斷，他需要使用isArray() 來(lái)判斷該type是否是一個(gè)數組類(lèi)型，然后使用getComponentType() 獲取他的元素的類(lèi)型

public void queryArrayType() throws NoSuchFieldException {
    Field field = Some.class.getDeclaredField("numbers");
    Class<?> type = field.getType();
    //一般來(lái)說(shuō)，判斷是否是某種類(lèi)型是可以使用isAssignableFrom
    // 判斷是否是數組類(lèi)型比較特殊，要使用isArray()這個(gè)函數
    if (type.isArray()){
        //獲得數組的類(lèi)型，使用getComponentType()這個(gè)方法
        Class<?> componentType = type.getComponentType();
        assertEquals(componentType,Integer.class);
    }
    else{
        throw new IllegalStateException();
    }
}

3、帶泛型的類(lèi)型

帶泛型的類(lèi)型就是類(lèi)似于List<String>這樣的類(lèi)型，我們現在的任務(wù)就是獲取到String這個(gè)類(lèi)型。

ParameterizedType表示參數化的類(lèi)型，例如Collection這樣的類(lèi)型。我們可以通過(guò)getGenericType()方法獲得該子類(lèi)，當你的類(lèi)型帶有參數的時(shí)候就會(huì )返回ParameterizedType,否則會(huì )返回普通的類(lèi)型(class)

那么具體是怎么操作的呢？

以獲得List<T>的類(lèi)型為例子

public void getListType() throws NoSuchFieldException {
    Field field = Some.class.getDeclaredField("list");
    //如果類(lèi)似于List<String>這樣的類(lèi)型就是一種GenericType
    //注意這是一種Type類(lèi)型
    Type type = field.getGenericType();
    if (type instanceof ParameterizedType){
        //泛型參數類(lèi)型
        ParameterizedType parameterizedType = (ParameterizedType)type;
        Type[] actualTypes = parameterizedType.getActualTypeArguments();
        //因為L(cháng)ist<String>獲得第一個(gè)泛型參數,因為只有一個(gè)，我們取第一個(gè)
        //如果我們有多個(gè)泛型參數，我們可以根據順序取不同的泛型參數
        assertEquals(actualTypes[0],String.class);
        //如果獲得List這個(gè)原始類(lèi)型呢？
        assertEquals(parameterizedType.getRawType(),List.class);
    }else{
        throw new IllegalStateException();
    }
}

4、復雜的嵌套類(lèi)型

假如是List<List<String>> 如何獲得最里面的類(lèi)型呢？

例子如下

public void getSubListType() throws NoSuchFieldException {
  //思考一下，如果我們有一個(gè)嵌套List，我們想拿到嵌套在最里面的類(lèi)型，那么我們可以這么做呢？
  //其實(shí)我們可以使用遞歸的思想去獲得最里面的類(lèi)型
  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、多個(gè)泛型參數

與第三個(gè)例子相似，只需要使用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();
    }
}

總結

以上總結了幾種常用的使用反射獲取屬性類(lèi)型的例子，稍加改造就可以寫(xiě)自己的工具類(lèi)了。希望對大家有幫助^_^