jdk1.5開始支持泛型，所以我們有時需要把泛型里定義的對象的類型拿到，研究了一下sample代碼

可以這樣來做

比如現(xiàn)在我定義了三個類Account， AccountItem和Product類。

Account聚合AccountItem，AccountItem聚合Prodcut。

都是用List<AccountItem>和List<Product>來表示的

我要實現(xiàn)一個功能，需要動態(tài)的傳入一個Class的類型，然后反射到啟動的List，根據List里定義的泛型，知道其中List的具體對象。

這個需求主要是由于現(xiàn)在的Json-lib還不支持深度的List的unmarshall，而只支持數(shù)組的方式。其實這里就是json-lib的beanfactory用到ezmorpher，而ezmorpher不支持泛型的定義方式，所以不知道類型，全轉成MorpherDynBean，這樣的對象是我們不需要的。

這樣需要修改ezmorpher的代碼，注入自己的MorpherBean的processor，這個processor就根據泛型拿到，我們需要轉型的對象。

代碼片段如下

引用:

Field[] fs = clazz.getDeclaredFields(); // 得到所有的fields

for(Field f : fs) 
{ 
    Class fieldClazz = f.getType(); // 得到field的class及類型全路徑

    if(fieldClazz.isPrimitive())  continue;  //【1】 //判斷是否為基本類型

    if(fieldClazz.getName().startsWith("java.lang")) continue; //getName()返回field的類型全路徑；

    if(fieldClazz.isAssignableFrom(List.class)) //【2】
    { 
             Type fc = f.getGenericType(); // 關鍵的地方，如果是List類型，得到其Generic的類型

             if(fc == null) continue;

             if(fc instanceof ParameterizedType) // 【3】如果是泛型參數(shù)的類型 
            { 
                   ParameterizedType pt = (ParameterizedType) fc;

                   Class genericClazz = (Class)pt.getActualTypeArguments()[0]; //【4】 得到泛型里的class類型對象。

                   m.put(f.getName(), genericClazz);

                   Map<String, Class> m1 = prepareMap(genericClazz);

                   m.putAll(m1); 
             } 
      } 
}

【解釋】：

1、isPrimitive

public boolean isPrimitive()

 3、ParameterizedType 表示參數(shù)化類型，如 Collection<String>。

 4、getGenericSuperclass, getSuperclass, getActualTypeArguments

     說明

           1.Class<? super T> getSuperclass():返回本類的父類

           2.Type getGenericSuperclass():返回本類的父類,包含泛型參數(shù)信息

      例子

          1.ClassA.java

             public class  ClassA <T>{     
                 private T obj;     
                 public void setObject(T obj) {      this.obj = obj;  }   
                 public T getObject() {    return obj;   }     
           } 

         2.Test.java

             import java.lang.reflect.Type;    
             import java.lang.reflect.ParameterizedType;   
             public class Test<T> extends ClassA<T>{     
                        public static void main(String args[]) throws Exception{     
                                 System.out.println("======getSuperclass======:");    
                                 System.out.println(Test.class.getSuperclass().getName());   
                                 System.out.println("======getGenericSuperclass======:");   
                                 Type t = Test.class.getGenericSuperclass();    
                                 System.out.println(t);     
                                 if (ParameterizedType.class.isAssignableFrom(t.getClass())) {  
                                          System.out.print("----------->getActualTypeArguments:");     
                                          for (Type t1:((ParameterizedType)t).getActualTypeArguments()) {     
                                                         System.out.print(t1 + ",");     
                                           }     
                                          System.out.println();     
                                 }  
                     }   
  
               } 

              輸出結果:

                    ======getSuperclass======:

                    ClassA

                    ======getGenericSuperclass======:

                    ClassA<T>

                    ----------->getActualTypeArguments:T,