泛型工具类GenericsUtils

  1. package cn.com.tcgroup.yunlu.commons;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.lang.reflect.Method;  
  5. import java.lang.reflect.ParameterizedType;  
  6. import java.lang.reflect.Type;  
  7. import java.util.ArrayList;  
  8. import java.util.List;  
  9.   
  10. /** 
  11.  * 泛型工具类 
  12.  */  
  13. public class GenericsUtils {  
  14.     /** 
  15.      * 通过反射,获得指定类的父类的泛型参数的实际类型. 如DaoSupport<Buyer> 
  16.      *  
  17.      * @param clazz 
  18.      *            clazz 需要反射的类,该类必须继承范型父类 
  19.      * @param index 
  20.      *            泛型参数所在索引,从0开始. 
  21.      * @return 范型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回 
  22.      *         <code>Object.class</code> 
  23.      */  
  24.     @SuppressWarnings("unchecked")  
  25.     public static Class getSuperClassGenricType(Class clazz, int index) {  
  26.   
  27.         Type genType = clazz.getGenericSuperclass();// 得到泛型父类  
  28.   
  29.         // 如果没有实现ParameterizedType接口,即不支持泛型,直接返回Object.class  
  30.         if (!(genType instanceof ParameterizedType)) {  
  31.   
  32.             return Object.class;  
  33.         }  
  34.   
  35.         // 返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends  
  36.         // DaoSupport<Buyer,Contact>就返回Buyer和Contact类型  
  37.         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();  
  38.         if (index >= params.length || index < 0) {  
  39.   
  40.             throw new RuntimeException("你输入的索引"  
  41.                     + (index < 0 ? "不能小于0" : "超出了参数的总数"));  
  42.         }  
  43.         if (!(params[index] instanceof Class)) {  
  44.   
  45.             return Object.class;  
  46.         }  
  47.         return (Class) params[index];  
  48.     }  
  49.   
  50.     /** 
  51.      * 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如DaoSupport<Buyer> 
  52.      *  
  53.      * @param clazz 
  54.      *            clazz 需要反射的类,该类必须继承泛型父类 
  55.      * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回 
  56.      *         <code>Object.class</code> 
  57.      */  
  58.     @SuppressWarnings("unchecked")  
  59.     public static Class getSuperClassGenricType(Class clazz) {  
  60.   
  61.         return getSuperClassGenricType(clazz, 0);  
  62.     }  
  63.   
  64.     /** 
  65.      * 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){} 
  66.      *  
  67.      * @param Method 
  68.      *            method 方法 
  69.      * @param int index 泛型参数所在索引,从0开始. 
  70.      * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回 
  71.      *         <code>Object.class</code> 
  72.      */  
  73.     @SuppressWarnings("unchecked")  
  74.     public static Class getMethodGenericReturnType(Method method, int index) {  
  75.   
  76.         Type returnType = method.getGenericReturnType();  
  77.   
  78.         if (returnType instanceof ParameterizedType) {  
  79.   
  80.             ParameterizedType type = (ParameterizedType) returnType;  
  81.             Type[] typeArguments = type.getActualTypeArguments();  
  82.   
  83.             if (index >= typeArguments.length || index < 0) {  
  84.   
  85.                 throw new RuntimeException("你输入的索引"  
  86.                         + (index < 0 ? "不能小于0" : "超出了参数的总数"));  
  87.             }  
  88.             return (Class) typeArguments[index];  
  89.         }  
  90.         return Object.class;  
  91.     }  
  92.   
  93.     /** 
  94.      * 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){} 
  95.      *  
  96.      * @param Method 
  97.      *            method 方法 
  98.      * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回 
  99.      *         <code>Object.class</code> 
  100.      */  
  101.     @SuppressWarnings("unchecked")  
  102.     public static Class getMethodGenericReturnType(Method method) {  
  103.   
  104.         return getMethodGenericReturnType(method, 0);  
  105.     }  
  106.   
  107.     /** 
  108.      * 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, 
  109.      * Buyer> maps, List<String> names){} 
  110.      *  
  111.      * @param Method 
  112.      *            method 方法 
  113.      * @param int index 第几个输入参数 
  114.      * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回空集合 
  115.      */  
  116.     @SuppressWarnings("unchecked")  
  117.     public static List<Class> getMethodGenericParameterTypes(Method method,  
  118.             int index) {  
  119.   
  120.         List<Class> results = new ArrayList<Class>();  
  121.         Type[] genericParameterTypes = method.getGenericParameterTypes();  
  122.   
  123.         if (index >= genericParameterTypes.length || index < 0) {  
  124.   
  125.             throw new RuntimeException("你输入的索引"  
  126.                     + (index < 0 ? "不能小于0" : "超出了参数的总数"));  
  127.         }  
  128.         Type genericParameterType = genericParameterTypes[index];  
  129.   
  130.         if (genericParameterType instanceof ParameterizedType) {  
  131.   
  132.             ParameterizedType aType = (ParameterizedType) genericParameterType;  
  133.             Type[] parameterArgTypes = aType.getActualTypeArguments();  
  134.             for (Type parameterArgType : parameterArgTypes) {  
  135.                 Class parameterArgClass = (Class) parameterArgType;  
  136.                 results.add(parameterArgClass);  
  137.             }  
  138.             return results;  
  139.         }  
  140.         return results;  
  141.     }  
  142.   
  143.     /** 
  144.      * 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> 
  145.      * maps, List<String> names){} 
  146.      *  
  147.      * @param Method 
  148.      *            method 方法 
  149.      * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回空集合 
  150.      */  
  151.     @SuppressWarnings("unchecked")  
  152.     public static List<Class> getMethodGenericParameterTypes(Method method) {  
  153.   
  154.         return getMethodGenericParameterTypes(method, 0);  
  155.     }  
  156.   
  157.     /** 
  158.      * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names; 
  159.      *  
  160.      * @param Field 
  161.      *            field 字段 
  162.      * @param int index 泛型参数所在索引,从0开始. 
  163.      * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回 
  164.      *         <code>Object.class</code> 
  165.      */  
  166.     @SuppressWarnings("unchecked")  
  167.     public static Class getFieldGenericType(Field field, int index) {  
  168.   
  169.         Type genericFieldType = field.getGenericType();  
  170.   
  171.         if (genericFieldType instanceof ParameterizedType) {  
  172.   
  173.             ParameterizedType aType = (ParameterizedType) genericFieldType;  
  174.             Type[] fieldArgTypes = aType.getActualTypeArguments();  
  175.             if (index >= fieldArgTypes.length || index < 0) {  
  176.   
  177.                 throw new RuntimeException("你输入的索引"  
  178.                         + (index < 0 ? "不能小于0" : "超出了参数的总数"));  
  179.             }  
  180.             return (Class) fieldArgTypes[index];  
  181.         }  
  182.         return Object.class;  
  183.     }  
  184.   
  185.     /** 
  186.      * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names; 
  187.      *  
  188.      * @param Field 
  189.      *            field 字段 
  190.      * @param int index 泛型参数所在索引,从0开始. 
  191.      * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回 
  192.      *         <code>Object.class</code> 
  193.      */  
  194.     @SuppressWarnings("unchecked")  
  195.     public static Class getFieldGenericType(Field field) {  
  196.   
  197.         return getFieldGenericType(field, 0);  
  198.     }  

你可能感兴趣的:(generics)