Java通过反射读取泛型

1.在这里有必要先提一句关于javabean，建议有一个构造器，而不是必须要写的，这是一个良好的习惯。

这样做肯定是有好处的，如果你的一个类写了带参的构造方法，而没有写空的构造方法，那么，如有有一个类继承了你这个类，那么这个类必须重写那个带参的构造方法，不写就会报错，所以这就会带来不必要的麻烦，所以我们一般都会写一个空的构造方法，这是一个良好的习惯。

以下是我使用泛型中，使用到的一个javabean，附上源码（其实没啥用，就是怕看的时候不知道User哪里的）

package bean;

public class User {
    private int id;
    private int age;
    private String uname;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    public User(int id, int age, String uname) {
        super();
        this.id = id;
        this.age = age;
        this.uname = uname;
    }

    //无参构造
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

}

2.使用泛型来读取泛型的信息，通过读取方法的参数，读取方法的返回值

package com.waibizi;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

import bean.User;

/**
 * 通过反射读取泛型信息
 * @author 吴典秋
 *
 */

public class Get_generic_info {

    public void test01(Map<String,User> map,List<User> list){
        System.out.println("Demo04.test01()");
    }

    public Map<Integer,User> test02(){
        System.out.println("Demo04.test02()");
        return null;
    }

    @SuppressWarnings("all")   //压制所有的警告
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        try {
            //获得指定方法参数泛型信息
            Method m = Get_generic_info.class.getMethod("test01", Map.class,List.class);

            Type[] t = m.getGenericParameterTypes();
            for (Type paramType : t) {

                System.out.println("#"+paramType);

                if(paramType instanceof ParameterizedType){

                    Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();

                    for (Type genericType : genericTypes) {
                        System.out.println("泛型类型："+genericType);
                    }

                }

            }

            //获得指定方法返回值泛型信息
            Method m2 = Get_generic_info.class.getMethod("test02", null);
            Type returnType = m2.getGenericReturnType();
            if(returnType instanceof ParameterizedType){
                    Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();

                    for (Type genericType : genericTypes) {
                        System.out.println("返回值，泛型类型："+genericType);
                    }

            }

        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}