Java反射获取泛型工具类

package com.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

/**
 * 泛型工具类
 * @author Admin<br/>
 * 上午9:45:54<br/>
 * cloudfirm<br/>
 * 2013<br/>
 * HibernateAnnotation<br/>
 */
public class GenericUtils {

    
     /**
      *
      * 功能:通过反射,获得指定类的父类的泛型参数的实际类型<br/>
      * @param clazz
      *        clazz 需要反射的类,该类必须继承泛型父类
      * @param index
      *         泛型参数所在索引,从0开始
      * @return 泛型参数的实际参数,如果没有实现ParameterizedType接口,即不支持泛型,
      *          所以直接返回Object.class
      * 2013-4-8 上午9:47:32
      */
     public static Class<?> getSuperClassGenericType(Class<?> clazz,int index){
    
       /** 得到泛型父类*/
       Type genType = clazz.getGenericSuperclass();
       /** 如果没有实现ParameterizedTyper接口,即不支持泛型,直接返回Object.class*/
       if (!(genType instanceof ParameterizedType)) {
           
            return Object.class;
       }
       Type[] params = ((ParameterizedType)genType).getActualTypeArguments();
       if (index >= params.length || index < 0) {
           
            throw new RuntimeException("你输入的索引"+(index < 0 ?"不能小于0":"超出了参数的总数"));
       }
       if (!(params[index] instanceof Class)) {
           
            return Object.class;
       }
       return (Class<?>)params[index];
     }
     
     /**
      *
      * 功能:通过反射,获取指定类的父类的第一个泛型参数的实际类型<br/>
      * @param clazz
      *        clazz 需要反射的类,该类必须继承泛型父类
      * @return 泛型参数的实际类型,如果没有实现ParameterizedType接口,即不支持泛型,
      *          所以直接返回Object.class
      * 2013-4-8 上午10:09:15
      */
     public static Class<?> getSuperClassGenericType(Class<?> clazz){
         
     return getSuperClassGenericType(clazz,0);
     }
     
     /**
      *
      * 功能:通过反射,获得方法返回值泛型参数的实际类型<br/>
      * @param Method
      *         method方法
      * @param int index 泛型参数所在索引,从0开始
      * @return 泛型参数的实际类型,如果没有实现ParameterizedType接口,即不支持泛型,
      *          所以直接返回Object.class
      * 2013-4-8 上午10:26:24
      */
     public static Class<?> getMethodGenericReturnType(Method method,int index) {
    
        Type returnType = method.getGenericReturnType();
        if (returnType instanceof ParameterizedType) {
        
        Type[] typeArguments = ((ParameterizedType)returnType).getActualTypeArguments();
        if (index >= typeArguments.length || index < 0) {
               
                throw new RuntimeException("你输入的索引"+(index < 0 ?"不能小于0":"超出了参数的总数"));
        }
        if (!(typeArguments[index] instanceof Class)) {
            
            return Object.class;
        }
        return (Class<?>)typeArguments[index];
        }
        return Object.class;
     }
     
     /**
      *
      * 功能:通过反射,获得方法返回值第一个泛型参数的实际类型<br/>
      * @param Method
      *        method方法
      * @return 泛型参数的实际类型,如果没有实现ParameterizedType接口,
      *          即不支持泛型,所以直接返回Object.class
      * 2013-4-8 上午11:00:07
      */
     public static Class<?> getMethodGenericReturnType(Method method){
    
     return getMethodGenericReturnType(method,0);
     }
     
     /**
      *
      * 功能:通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型<br/>
      * @param Method
      *         method方法
      * @param int index 第几个输入参数
      * @return 输入参数的泛型参数的实际类型集合,如果没有实现ParameterizedType接口,
      *          即不支持泛型,所以直接返回空集合
      * 2013-4-8 上午11:19:31
      */
     public static List<Class<?>> getMethodGenericParameterTypes(Method method,int index){
    
     List<Class<?>> results = new ArrayList<Class<?>>();
     Type[] genericParamTypes = method.getGenericParameterTypes();
     if (index >= genericParamTypes.length || index < 0) {
           
            throw new RuntimeException("你输入的索引"+(index < 0 ?"不能小于0":"超出了参数的总数"));
     }
     Type genericParamType = genericParamTypes[index];
     if (genericParamType instanceof ParameterizedType) {
         
         ParameterizedType paramType = (ParameterizedType)genericParamType;
         Type[] paramArgTypes = paramType.getActualTypeArguments();
         Class<?> temp = null;
         for (Type paramArgType : paramArgTypes) {
        
         if (!(paramArgType instanceof Class)) {
             
             temp = Object.class;
         } else {
             
             temp = (Class<?>)paramArgType;
         }
         results.add(temp);
         }
     }
     return results;
     }
     
     /**
      *
      * 功能:通过反射,获得方法输入参数第1个输入参数的所有泛型参数的实际类型<br/>
      * @param Method
      *         method方法
      * @return 输入参数的泛型参数的实际类型集合,如果没有实现ParameterizedType接口,
      *          即不支持泛型,所以直接返回空集合
      * 2013-4-8 上午11:19:31
      */
     public static List<Class<?>> getMethodGenericParameterTypes(Method method){
    
     return getMethodGenericParameterTypes(method,0);
     }
     
     /**
      *
      * 功能:通过反射,获得Field泛型参数的实际类型<br/>
      * @param Field
      *         field字段
      * @param int index 泛型参数所在索引,从0开始
      * @return 泛型参数的实际类型,如果没有实现ParameterizedType接口,即不支持泛型,
      *          所以返回Object.class
      * 2013-4-8 上午11:52:21
      */
     public static Class<?> getFieldGenericType(Field field,int index){
    
     Type genericFieldType = field.getGenericType();
     if (genericFieldType instanceof ParameterizedType) {
         
         ParameterizedType paramType = (ParameterizedType)genericFieldType;
         Type[] paramArgTypes = paramType.getActualTypeArguments();
         if (index >= paramArgTypes.length || index < 0) {
               
          throw new RuntimeException("你输入的索引"+(index < 0 ?"不能小于0":"超出了参数的总数"));
         }
         if (!(paramArgTypes[index] instanceof Class)) {
        
         return Object.class;
         }
         return (Class<?>)paramArgTypes[index];
     }
     return Object.class;
     }
     
     /**
      *
      * 功能:通过反射,获得Field第一个泛型参数的实际类型<br/>
      * @param Field
      *         field字段
      * @return 泛型参数的实际类型,如果没有实现ParameterizedType接口,即不支持泛型,
      *          所以返回Object.class
      * 2013-4-8 上午11:52:21
      */
     public static Class<?> getFieldGenericType(Field field){
    
     return  getFieldGenericType(field,0);
     }
}