java里的类型Type

 

有时候，我们需要得到泛型的具体类信息。

如操作DAO时:

public abstract class GenericDaoIbatis<T, PK extends Serializable> implements GenericDao<T,PK>{  
    private SqlMapClientTemplate sqlTemplate;

    protected SqlMapClientTemplate getSqlTemplate() {
	return sqlTemplate;
    }

    private Class<T> persistentClass;  
    @SuppressWarnings("unchecked")  
    public BaseDaoImpl() {  
       Type genType = clazz.getGenericSuperclass();
       Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
       this.persistentClass = params[0];  
    }
    //……&……
}
  

   这时我们需要得到泛型参数具体类的信息，即得到T表示的具体类的信息，这里我们用到了ParameterizedType这个类，调用getActualTypeArguments()方法我们就能得到泛型的所有参数，它返回的是一个数组。

 

 

    首先我们要知道java里定义了哪些类型(Type)。java的类型都实现了java.lang.reflect.Type的接口， 主要有五类：raw types, parameterized types, array types, type variables and primitive types。

raw types: 就是一般类型，如String, Number,等(普通的类)

parameterized types: 含泛型定义的类，如：List, Map, etc..

array types: 含泛型定义的数组，数组内可以是parameterized types或type variables，如<K> K[]

type variables:  类型变量，不确定其类型。如：V, <V extends Number>

primitive types: int, float, double, etc..（基本类型）

在java内部有四个接口继承自Type，分别是GenericArrayType, ParameterizedType, TypeVariable<D>, WildcardType 。

其中，array types实现自GenericArrayType；parameterized types实现自ParameterizedType；type variables实现自TypeVariable<D>；WildcardType是形如 ?, ? extends Number一类的type. 需要注意的是, Class也是Type的一种实现。

import java.lang.reflect.Field;  
import java.lang.reflect.ParameterizedType;  
import java.lang.reflect.Type;  
import java.util.Map;  
  
public class TypePojo<E> {  
  
    private int primitive_type;  
    private Map<String, ? extends Integer> parameterized_type;  
    private E type_variable;  
    private E[] array_type;  
  
    public static void main(String[] args) {  
        Class pojoClass = TypePojo.class;  
        try {  
            // get primitive type  
            System.out.println("get primitive type-->");  
            Field primitive_type_field = pojoClass.getDeclaredField("primitive_type");  
            Type primitive_type = primitive_type_field.getGenericType();  
            System.out.println("Type Class: " + primitive_type.getClass() + " Type: " + primitive_type);  
            // get parameterized type  
            System.out.println("/nget parameterized type-->");  
            Field parameterized_type_field = pojoClass.getDeclaredField("parameterized_type");  
            Type parameterized_type = parameterized_type_field.getGenericType();  
            System.out.println("Type Class: " + parameterized_type.getClass() + " Type: " + parameterized_type);  
            // get WildcardType  
            System.out.println("get actual types-->");  
            ParameterizedType real_parameterized_type = (ParameterizedType) parameterized_type;  
            Type[] actualTypes = real_parameterized_type.getActualTypeArguments();  
            for (Type type : actualTypes) {  
                System.out.println("Type Class: " + type.getClass() + " Type: " + type);  
            }  
            // get type variables  
            System.out.println("/nget type variables-->");  
            Field type_variable_field = pojoClass.getDeclaredField("type_variable");  
            Type type_variable = type_variable_field.getGenericType();  
            System.out.println("Type Class: " + type_variable.getClass() + " Type: " + type_variable);  
            // get array type  
            System.out.println("/nget array type-->");  
            Field array_type_field = pojoClass.getDeclaredField("array_type");  
            Type array_type = array_type_field.getGenericType();  
            System.out.println("Type Class: " + array_type.getClass() + " Type: " + array_type);  
        } catch (SecurityException e) {  
            e.printStackTrace();  
        } catch (NoSuchFieldException e) {  
            e.printStackTrace();  
        }  
    }  
}