Java如何在运行时获取泛型信息？

package me.test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
/**
 * 如何在运行时获取某一个类的泛型信息？
 *
 *
 * 参考：http://blog.xebia.com/2009/02/acessing-generic-types-at-runtime-in-java/
 *
 * @author [e-mail]
 *
 * 运行结果：
============================类的泛型信息 :
接口：interface me.test.Main$I:true
　　　　泛型[0] = class java.lang.Class
　　　　泛型[1] = class java.lang.Class
　　声明于 = class me.test.Main
接口：interface java.lang.Runnable:

============================方法的泛型信息 :
方法：public void me.test.Main$C.run():
　　返回值 = void
　　声明于 = class me.test.Main$C
方法：public java.lang.Integer me.test.Main$C.get(java.lang.String):
　　参数[0] = class java.lang.String
　　返回值 = class java.lang.Integer
　　声明于 = class me.test.Main$C
方法：public java.util.Map me.test.Main$C.get(java.util.List):
　　参数[0] = interface java.util.List
　　　　泛型[0] = class java.lang.Class
　　返回值 = interface java.util.Map
　　　　泛型[0] = class java.lang.Class
　　　　泛型[1] = class java.lang.Class
　　声明于 = class me.test.Main$C
方法：public java.lang.Object me.test.Main$C.get(java.lang.Object):
　　参数[0] = class java.lang.Object
　　返回值 = class java.lang.Object
　　声明于 = class me.test.Main$C

============================获取类C的字段的泛型信息 :
字段：list:
　　类型= interface java.util.List
　　　　泛型[0] = class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
 */
public class Main {
    // 我们定义了一个泛型的接口 I
    public static interface I<K, V> {
        V get(K k);
    }

    // 我们定义了实现该接口类 C
    public static class C implements I<String, Integer>, Runnable {
        public List<?> list;
        @Override
        public void run() {};
        @Override
        public Integer get(String k) { return null; }
        public Map<String, String> get(List<Object> l) { return null; }
    }

    //我们如何在运行时获取类C中各个字段，方法上的泛型信息呢？
    public static void main(String[] args) {
        System.out.println("============================类的泛型信息 :");
        for (Type t : C.class.getGenericInterfaces()) {
            if (t instanceof ParameterizedType) {
                ParameterizedType pT = (ParameterizedType) t;
                System.out.println("接口：" + pT.getRawType() + ":" + (pT.getRawType() == I.class));
                Type[] types = pT.getActualTypeArguments();
                for (int i = 0; i < types.length; i++) {
                    System.out.println("　　　　泛型[" + i + "] = " + types[i].getClass());
                }
                System.out.println("　　声明于 = " + pT.getOwnerType());
            } else {
                System.out.println("接口：" + t + ":");
            }
        }
        System.out.println();
        System.out.println("============================方法的泛型信息 :");
        Method[] methodArray = C.class.getDeclaredMethods();
        for (Method m : methodArray) {
            System.out.println("方法：" + m + ":");
            Type[] argTypes = m.getGenericParameterTypes();
            for (int i = 0; i < argTypes.length; i++) {
                Type t = argTypes[0];
                if (t instanceof ParameterizedType) {
                    ParameterizedType pT = (ParameterizedType) t;
                    System.out.println("　　参数[" + i + "] = " + pT.getRawType());
                    Type[] types = pT.getActualTypeArguments();
                    for (int j = 0; j < types.length; j++) {
                        System.out.println("　　　　泛型[" + j + "] = " + types[j].getClass());
                    }
                } else {
                    System.out.println("　　参数[" + i + "] = " + t);
                }
            }
            Type rtnType = m.getGenericReturnType();
            if (rtnType instanceof ParameterizedType) {
                ParameterizedType pT = (ParameterizedType) rtnType;
                System.out.println("　　返回值 = " + pT.getRawType());
                Type[] types = pT.getActualTypeArguments();
                for (int j = 0; j < types.length; j++) {
                    System.out.println("　　　　泛型[" + j + "] = " + types[j].getClass());
                }
            } else {
                System.out.println("　　返回值 = " + rtnType);
            }
            System.out.println("　　声明于 = " + m.getDeclaringClass());

        }

        System.out.println();
        System.out.println("============================获取类C的字段的泛型信息 :");
        for (Field f : C.class.getDeclaredFields()) {
            Type t = f.getGenericType();
            System.out.println("字段：" + f.getName() + ":");
            if (t instanceof ParameterizedType) {
                ParameterizedType pT = (ParameterizedType) t;
                System.out.println("　　类型= " + pT.getRawType());
                Type[] types = pT.getActualTypeArguments();
                for (int j = 0; j < types.length; j++) {
                    System.out.println("　　　　泛型[" + j + "] = " + types[j].getClass());
                }
            } else {
                System.out.println("字段：" + f.getName() + ":");
                System.out.println("　　类型= " + t);
            }
        }
    }
}