计算机程序的思惟逻辑 (84) - 反射

本系列文章经补充和完善，已修订整理成书《Java编程的逻辑》（马俊昌著），由机械工业出版社华章分社出版，于2018年1月上市热销，读者好评如潮！各大网店和书店有售，欢迎购买：京东自营连接

上节介绍完了并发，从本节开始，咱们来探讨Java中的一些动态特性，包括反射、类加载器、注解和动态代理等。利用这些特性，能够以优雅的方式实现一些灵活和通用的功能，常常用于各类框架、库和系统程序中，好比：

• 在63节介绍的实用序列化库Jackson，利用反射和注解实现了通用的序列化/反序列化机制
• 有多种库如Spring MVC, Jersey用于处理Web请求，利用反射和注解，能方便的将用户的请求参数和内容转换为Java对象，将Java对象转变为响应内容
• 有多种库如Spring, Guice利用这些特性实现了对象管理容器，方便程序员管理对象的生命周期以及其中复杂的依赖关系
• 应用服务器好比Tomcat利用类加载器实现不一样应用之间的隔离、JSP技术也利用类加载器实现修改代码不用重启就能生效的特性
• 面向方面的编程(AOP - Aspect Oriented Programming)将编程中通用的关注点好比日志记录、安全检查等与业务的主体逻辑相分离，减小冗余代码，提升程序的可维护性，AOP须要依赖上面的这些特性来实现

本节先来看反射机制。

在通常操做数据的时候，咱们都是知道而且依赖于数据的类型的，好比：

• 根据类型使用new建立对象
• 根据类型定义变量，类型多是基本类型、类、接口或数组
• 将特定类型的对象传递给方法
• 根据类型访问对象的属性，调用对象的方法

编译器也是根据类型，进行代码的检查编译。

反射不同，它是在运行时，而非编译时，动态获取类型的信息，好比接口信息、成员信息、方法信息、构造方法信息等，根据这些动态获取到的信息建立对象、访问/修改为员、调用方法等。这么说比较抽象，下面咱们会具体来讲明，反射的入口是名称为"Class"的类，咱们来看下。

"Class"类

获取Class对象

咱们在17节介绍过类和继承的基本实现原理，咱们提到，每一个已加载的类在内存都有一份类信息，每一个对象都有指向它所属类信息的引用。Java中，类信息对应的类就是java.lang.Class，注意不是小写的class，class是定义类的关键字，全部类的根父类Object有一个方法，能够获取对象的Class对象：

public final native Class<?> getClass()
复制代码

Class是一个泛型类，有一个类型参数，getClass()并不知道具体的类型，因此返回Class<?>。

获取Class对象不必定须要实例对象，若是在写程序时就知道类名，可使用<类名>.class获取Class对象，好比：

Class<Date> cls = Date.class;
复制代码

接口也有Class对象，且这种方式对于接口也是适用的，好比：

Class<Comparable> cls = Comparable.class;
复制代码

基本类型没有getClass方法，但也都有对应的Class对象，类型参数为对应的包装类型，好比：

Class<Integer> intCls = int.class;
Class<Byte> byteCls = byte.class;
Class<Character> charCls = char.class;
Class<Double> doubleCls = double.class;
复制代码

void做为特殊的返回类型，也有对应的Class：

Class<Void> voidCls = void.class;
复制代码

对于数组，每种类型都有对应数组类型的Class对象，每一个维度都有一个，即一维数组有一个，二维数组有一个不一样的，好比：

String[] strArr = new String[10];
int[][] twoDimArr = new int[3][2];
int[] oneDimArr = new int[10];
Class<? extends String[]> strArrCls = strArr.getClass();
Class<? extends int[][]> twoDimArrCls = twoDimArr.getClass();
Class<? extends int[]> oneDimArrCls = oneDimArr.getClass();
复制代码

枚举类型也有对应的Class，好比：

enum Size {
    SMALL, MEDIUM, BIG
}

Class<Size> cls = Size.class;
复制代码

Class有一个静态方法forName，能够根据类名直接加载Class，获取Class对象,好比：

try {
    Class<?> cls = Class.forName("java.util.HashMap");
    System.out.println(cls.getName());
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
复制代码

注意forName可能抛出异常ClassNotFoundException。

有了Class对象后，咱们就能够了解到关于类型的不少信息，并基于这些信息采起一些行动，Class的方法不少，大部分比较简单直接，容易理解，下面，咱们分为若干组，进行简要介绍。

名称信息

Class有以下方法，能够获取与名称有关的信息：

public String getName() public String getSimpleName() public String getCanonicalName() public Package getPackage() 复制代码

getSimpleName不带包信息，getName返回的是Java内部使用的真正的名字，getCanonicalName返回的名字更为友好，getPackage返回的是包信息，它们的不一样能够看以下表格：

须要说明的是数组类型的getName返回值，它使用前缀[表示数组，有几个[表示是几维数组，数组的类型用一个字符表示，I表示int，L表示类或接口，其余类型与字符的对应关系为: boolean(Z), byte(B), char(C), double(D), float(F), long(J), short(S)，对于引用类型的数组，注意最后有一个分号";"。

字段(实例和静态变量)信息

类中定义的静态和实例变量都被称为字段，用类Field表示，位于包java.util.reflect下，后文涉及到的反射相关的类都位于该包下，Class有四个获取字段信息的方法：

//返回全部的public字段，包括其父类的，若是没有字段，返回空数组
public Field[] getFields()
//返回本类声明的全部字段，包括非public的，但不包括父类的
public Field[] getDeclaredFields()
//返回本类或父类中指定名称的public字段，找不到抛出异常NoSuchFieldException
public Field getField(String name) //返回本类中声明的指定名称的字段，找不到抛出异常NoSuchFieldException public Field getDeclaredField(String name) 复制代码

Field也有不少方法，能够获取字段的信息，也能够经过Field访问和操做指定对象中该字段的值，基本方法有：

//获取字段的名称
public String getName() //判断当前程序是否有该字段的访问权限 public boolean isAccessible() //flag设为true表示忽略Java的访问检查机制，以容许读写非public的字段 public void setAccessible(boolean flag) //获取指定对象obj中该字段的值 public Object get(Object obj) //将指定对象obj中该字段的值设为value public void set(Object obj, Object value) 复制代码

在get/set方法中，对于静态变量，obj被忽略，能够为null，若是字段值为基本类型，get/set会自动在基本类型与对应的包装类型间进行转换，对于private字段，直接调用get/set会抛出非法访问异常IllegalAccessException，应该先调用setAccessible(true)以关闭Java的检查机制。

看段简单的示例代码：

List<String> obj = Arrays.asList(new String[]{"老马","编程"});
Class<?> cls = obj.getClass();
for(Field f : cls.getDeclaredFields()){
    f.setAccessible(true);
    System.out.println(f.getName()+" - "+f.get(obj));
}
复制代码

代码比较简单，就不赘述了。咱们在ThreadLocal一节介绍过利用反射来清空ThreadLocal，这里重复下其代码，含义就比较清楚了：

protected void beforeExecute(Thread t, Runnable r) {
    try {
        //使用反射清空全部ThreadLocal
        Field f = t.getClass().getDeclaredField("threadLocals");
        f.setAccessible(true);
        f.set(t, null);
    } catch (Exception e) {
        e.printStackTrace();
    }
    super.beforeExecute(t, r);
}
复制代码

除了以上方法，Field还有不少别的方法，好比：

//返回字段的修饰符
public int getModifiers() //返回字段的类型 public Class<?> getType() //以基本类型操做字段 public void setBoolean(Object obj, boolean z) public boolean getBoolean(Object obj) public void setDouble(Object obj, double d) public double getDouble(Object obj) //查询字段的注解信息 public <T extends Annotation> T getAnnotation(Class<T> annotationClass) public Annotation[] getDeclaredAnnotations() 复制代码

getModifiers返回的是一个int，能够经过Modifier类的静态方法进行解读，好比，假定Student类有以下字段：

public static final int MAX_NAME_LEN = 255;
复制代码

能够这样查看该字段的修饰符：

Field f = Student.class.getField("MAX_NAME_LEN");
int mod = f.getModifiers();
System.out.println(Modifier.toString(mod));
System.out.println("isPublic: " + Modifier.isPublic(mod));
System.out.println("isStatic: " + Modifier.isStatic(mod));
System.out.println("isFinal: " + Modifier.isFinal(mod));
System.out.println("isVolatile: " + Modifier.isVolatile(mod));
复制代码

输出为：

public static final
isPublic: true
isStatic: true
isFinal: true
isVolatile: false
复制代码

关于注解，咱们下节再详细介绍。

方法信息

类中定义的静态和实例方法都被称为方法，用类Method表示，Class有四个获取方法信息的方法：

//返回全部的public方法，包括其父类的，若是没有方法，返回空数组
public Method[] getMethods()
//返回本类声明的全部方法，包括非public的，但不包括父类的
public Method[] getDeclaredMethods()
//返回本类或父类中指定名称和参数类型的public方法，找不到抛出异常NoSuchMethodException
public Method getMethod(String name, Class<?>... parameterTypes) //返回本类中声明的指定名称和参数类型的方法，找不到抛出异常NoSuchMethodException public Method getDeclaredMethod(String name, Class<?>... parameterTypes) 复制代码

Method也有不少方法，能够获取方法的信息，也能够经过Method调用对象的方法，基本方法有：

//获取方法的名称
public String getName() //flag设为true表示忽略Java的访问检查机制，以容许调用非public的方法 public void setAccessible(boolean flag) //在指定对象obj上调用Method表明的方法，传递的参数列表为args public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException 复制代码

对invoke方法，若是Method为静态方法，obj被忽略，能够为null，args能够为null，也能够为一个空的数组，方法调用的返回值被包装为Object返回，若是实际方法调用抛出异常，异常被包装为InvocationTargetException从新抛出，能够经过getCause方法获得原异常。

看段简单的示例代码：

Class<?> cls = Integer.class;
try {
    Method method = cls.getMethod("parseInt", new Class[]{String.class});
    System.out.println(method.invoke(null, "123"));
} catch (NoSuchMethodException e) {
    e.printStackTrace();
} catch (InvocationTargetException e) {
    e.printStackTrace();
}
复制代码

Method还有不少方法，能够获取方法的修饰符、参数、返回值、注解等信息，好比：

//获取方法的修饰符，返回值可经过Modifier类进行解读
public int getModifiers() //获取方法的参数类型 public Class<?>[] getParameterTypes() //获取方法的返回值类型 public Class<?> getReturnType() //获取方法声明抛出的异常类型 public Class<?>[] getExceptionTypes() //获取注解信息 public Annotation[] getDeclaredAnnotations() public <T extends Annotation> T getAnnotation(Class<T> annotationClass) //获取方法参数的注解信息 public Annotation[][] getParameterAnnotations() 复制代码

建立对象和构造方法

Class有一个方法，能够用它来建立对象：

public T newInstance() throws InstantiationException, IllegalAccessException 复制代码

它会调用类的默认构造方法(即无参public构造方法)，若是类没有该构造方法，会抛出异常InstantiationException。看个简单示例：

Map<String,Integer> map = HashMap.class.newInstance();
map.put("hello", 123);
复制代码

不少利用反射的库和框架都默认假定类有无参public构造方法，因此当类利用这些库和框架时要记住提供一个。

newInstance只能使用默认构造方法，Class还有一些方法，能够获取全部的构造方法：

//获取全部的public构造方法，返回值可能为长度为0的空数组
public Constructor<?>[] getConstructors()
//获取全部的构造方法，包括非public的
public Constructor<?>[] getDeclaredConstructors()
//获取指定参数类型的public构造方法，没找到抛出异常NoSuchMethodException
public Constructor<T> getConstructor(Class<?>... parameterTypes) //获取指定参数类型的构造方法，包括非public的，没找到抛出异常NoSuchMethodException public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 复制代码

类Constructor表示构造方法，经过它能够建立对象，方法为：

public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException 复制代码

好比：

Constructor<StringBuilder> contructor= StringBuilder.class
                    .getConstructor(new Class[]{int.class});
StringBuilder sb = contructor.newInstance(100);
复制代码

除了建立对象，Constructor还有不少方法，能够获取关于构造方法的不少信息，好比：

//获取参数的类型信息
public Class<?>[] getParameterTypes()
//构造方法的修饰符，返回值可经过Modifier类进行解读
public int getModifiers() //构造方法的注解信息 public Annotation[] getDeclaredAnnotations() public <T extends Annotation> T getAnnotation(Class<T> annotationClass) //构造方法中参数的注解信息 public Annotation[][] getParameterAnnotations() 复制代码

类型检查和转换

咱们在16节介绍过instanceof关键字，它能够用来判断变量指向的实际对象类型，instanceof后面的类型是在代码中肯定的，若是要检查的类型是动态的，可使用Class类的以下方法：

public native boolean isInstance(Object obj) 复制代码

也就是说，以下代码：

if(list instanceof ArrayList){
    System.out.println("array list");
}
复制代码

和下面代码的输出是相同的：

Class cls = Class.forName("java.util.ArrayList");
if(cls.isInstance(list)){
    System.out.println("array list");
}
复制代码

除了判断类型，在程序中也每每须要进行强制类型转换，好比：

List list = ..
if(list instanceof ArrayList){
    ArrayList arrList = (ArrayList)list;
}
复制代码

在这段代码中，强制转换到的类型是在写代码时就知道的，若是是动态的，可使用Class的以下方法：

public T cast(Object obj) 复制代码

好比：

public static <T> T toType(Object obj, Class<T> cls){
    return cls.cast(obj);
}
复制代码

isInstance/cast描述的都是对象和类之间的关系，Class还有一个方法，能够判断Class之间的关系：

// 检查参数类型cls可否赋给当前Class类型的变量
public native boolean isAssignableFrom(Class<?> cls);
复制代码

好比，以下表达式的结果都为true：

Object.class.isAssignableFrom(String.class)
String.class.isAssignableFrom(String.class)
List.class.isAssignableFrom(ArrayList.class)
复制代码

Class的类型信息

Class表明的类型既能够是普通的类、也能够是内部类，还能够是基本类型、数组等，对于一个给定的Class对象，它究竟是什么类型呢？能够经过如下方法进行检查：

//是不是数组
public native boolean isArray();  
//是不是基本类型
public native boolean isPrimitive();
//是不是接口
public native boolean isInterface();
//是不是枚举
public boolean isEnum() //是不是注解 public boolean isAnnotation() //是不是匿名内部类 public boolean isAnonymousClass() //是不是成员类 public boolean isMemberClass() //是不是本地类 public boolean isLocalClass() 复制代码

须要说明下匿名内部类、成员类与本地类的区别，本地类是指在方法内部定义的非匿名内部类，好比，以下代码：

public static void localClass(){
    class MyLocal {
    }
    Runnable r = new Runnable() {
        @Override
        public void run(){
            
        }
    };
    System.out.println(MyLocal.class.isLocalClass());
    System.out.println(r.getClass().isLocalClass());
}
复制代码

MyLocal定义在localClass方法内部，就是一个本地类，r的对象所属的类是一个匿名类，但不是本地类。

成员类也是内部类，定义在类内部、方法外部，它不是匿名类，也不是本地类。

类的声明信息

Class还有不少方法，能够获取类的声明信息，如修饰符、父类、实现的接口、注解等，以下所示：

//获取修饰符，返回值可经过Modifier类进行解读
public native int getModifiers() //获取父类，若是为Object，父类为null public native Class<? super T> getSuperclass() //对于类，为本身声明实现的全部接口，对于接口，为直接扩展的接口，不包括经过父类间接继承来的 public native Class<?>[] getInterfaces();
//本身声明的注解
public Annotation[] getDeclaredAnnotations()
//全部的注解，包括继承获得的
public Annotation[] getAnnotations()
//获取或检查指定类型的注解，包括继承获得的
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) 复制代码

内部类

关于内部类，Class有一些专门的方法，好比：

//获取全部的public的内部类和接口，包括从父类继承获得的
public Class<?>[] getClasses()
//获取本身声明的全部的内部类和接口
public Class<?>[] getDeclaredClasses()
//若是当前Class为内部类，获取声明该类的最外部的Class对象
public Class<?> getDeclaringClass()
//若是当前Class为内部类，获取直接包含该类的类
public Class<?> getEnclosingClass()
//若是当前Class为本地类或匿名内部类，返回包含它的方法
public Method getEnclosingMethod() 复制代码

类的加载

Class有两个静态方法，能够根据类名加载类：

public static Class<?> forName(String className)
public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
复制代码

ClassLoader表示类加载器，后面章节咱们会进一步介绍，initialize表示加载后，是否执行类的初始化代码(如static语句块)。第一个方法中没有传这些参数，至关于调用：

Class.forName(className, true, currentLoader)
复制代码

currentLoader表示加载当前类的ClassLoader。

这里className与Class.getName的返回值是一致的，好比，对于String数组：

String name = "[Ljava.lang.String;";
Class cls = Class.forName(name);
System.out.println(cls == String[].class);
复制代码

须要注意的是，基本类型不支持forName方法，也就是说，以下写法：

Class.forName("int");
复制代码

会抛出异常ClassNotFoundException，那如何根据原始类型的字符串构造Class对象呢？能够对Class.forName进行一下包装，好比：

public static Class<?> forName(String className) throws ClassNotFoundException{
    if("int".equals(className)){
        return int.class;
    }
    //其余基本类型...
    return Class.forName(className);
}
复制代码

反射与数组

对于数组类型，有一个专门的方法，能够获取它的元素类型：

public native Class<?> getComponentType()
复制代码

好比：

String[] arr = new String[]{};
System.out.println(arr.getClass().getComponentType());
复制代码

输出为：

class java.lang.String
复制代码

java.lang.reflect包中有一个针对数组的专门的类Array（注意不是java.util中的Arrays)，提供了对于数组的一些反射支持，以便于统一处理多种类型的数组，主要方法有：

//建立指定元素类型、指定长度的数组，
public static Object newInstance(Class<?> componentType, int length) //建立多维数组 public static Object newInstance(Class<?> componentType, int... dimensions) //获取数组array指定的索引位置index处的值 public static native Object get(Object array, int index) //修改数组array指定的索引位置index处的值为value public static native void set(Object array, int index, Object value) //返回数组的长度 public static native int getLength(Object array) 复制代码

须要注意的是，在Array类中，数组是用Object而非Object[]表示的，这是为何呢？这是为了方便处理多种类型的数组，int[]，String[]都不能与Object[]相互转换，但能够与Object相互转换，好比：

int[] intArr = (int[])Array.newInstance(int.class, 10);
String[] strArr = (String[])Array.newInstance(String.class, 10);
复制代码

除了以Object类型操做数组元素外，Array也支持以各类基本类型操做数组元素，如：

public static native double getDouble(Object array, int index) public static native void setDouble(Object array, int index, double d) public static native void setLong(Object array, int index, long l) public static native long getLong(Object array, int index) 复制代码

反射与枚举

枚举类型也有一个专门方法，能够获取全部的枚举常量：

public T[] getEnumConstants()
复制代码

应用示例

介绍了Class的这么多方法，有什么用呢？咱们看个简单的示例，利用反射实现一个简单的通用序列化/反序列化类SimpleMapper，它提供两个静态方法：

public static String toString(Object obj) public static Object fromString(String str) 复制代码

toString将对象obj转换为字符串，fromString将字符串转换为对象。为简单起见，咱们只支持最简单的类，即有默认构造方法，成员类型只有基本类型、包装类或String。另外，序列化的格式也很简单，第一行为类的名称，后面每行表示一个字段，用字符'='分隔，表示字段名称和字符串形式的值。SimpleMapper能够这么用：

public class SimpleMapperDemo {
    static class Student {
        String name;
        int age;
        Double score;

        public Student() {
        }

        public Student(String name, int age, Double score) {
            super();
            this.name = name;
            this.age = age;
            this.score = score;
        }

        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
        }
    }

    public static void main(String[] args) {
        Student zhangsan = new Student("张三", 18, 89d);
        String str = SimpleMapper.toString(zhangsan);
        Student zhangsan2 = (Student) SimpleMapper.fromString(str);
        System.out.println(zhangsan2);
    }
}
复制代码

代码先调用toString方法将对象转换为了String，而后调用fromString方法将字符串转换为了Student，新对象的值与原对象是同样的，输出以下所示：

Student [name=张三, age=18, score=89.0]
复制代码

咱们来看SimpleMapper的示例实现(主要用于演示原理，在生产中谨慎使用)，toString的代码为：

public static String toString(Object obj) {
    try {
        Class<?> cls = obj.getClass();
        StringBuilder sb = new StringBuilder();
        sb.append(cls.getName() + "\n");
        for (Field f : cls.getDeclaredFields()) {
            if (!f.isAccessible()) {
                f.setAccessible(true);
            }
            sb.append(f.getName() + "=" + f.get(obj).toString() + "\n");
        }
        return sb.toString();
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}
复制代码

fromString的代码为：

public static Object fromString(String str) {
    try {
        String[] lines = str.split("\n");
        if (lines.length < 1) {
            throw new IllegalArgumentException(str);
        }
        Class<?> cls = Class.forName(lines[0]);
        Object obj = cls.newInstance();
        if (lines.length > 1) {
            for (int i = 1; i < lines.length; i++) {
                String[] fv = lines[i].split("=");
                if (fv.length != 2) {
                    throw new IllegalArgumentException(lines[i]);
                }
                Field f = cls.getDeclaredField(fv[0]);
                if(!f.isAccessible()){
                    f.setAccessible(true);
                }
                setFieldValue(f, obj, fv[1]);
            }
        }
        return obj;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
复制代码

它调用了setFieldValue方法对字段设置值，其代码为：

private static void setFieldValue(Field f, Object obj, String value) throws Exception {
    Class<?> type = f.getType();
    if (type == int.class) {
        f.setInt(obj, Integer.parseInt(value));
    } else if (type == byte.class) {
        f.setByte(obj, Byte.parseByte(value));
    } else if (type == short.class) {
        f.setShort(obj, Short.parseShort(value));
    } else if (type == long.class) {
        f.setLong(obj, Long.parseLong(value));
    } else if (type == float.class) {
        f.setFloat(obj, Float.parseFloat(value));
    } else if (type == double.class) {
        f.setDouble(obj, Double.parseDouble(value));
    } else if (type == char.class) {
        f.setChar(obj, value.charAt(0));
    } else if (type == boolean.class) {
        f.setBoolean(obj, Boolean.parseBoolean(value));
    } else if (type == String.class) {
        f.set(obj, value);
    } else {
        Constructor<?> ctor = type.getConstructor(new Class[] { String.class });
        f.set(obj, ctor.newInstance(value));
    }
}
复制代码

setFieldValue根据字段的类型，将字符串形式的值转换为了对应类型的值，对于基本类型和String之外的类型，它假定该类型有一个以String类型为参数的构造方法。

反射与泛型

在介绍泛型的时候，咱们提到，泛型参数在运行时会被擦除，这里，咱们须要补充一下，在类信息Class中依然有关于泛型的一些信息，能够经过反射获得，泛型涉及到一些更多的方法和类，上面的介绍中进行了忽略，这里简要补充下。

Class有以下方法，能够获取类的泛型参数信息：

public TypeVariable<Class<T>>[] getTypeParameters()
复制代码

Field有以下方法：

public Type getGenericType() 复制代码

Method有以下方法：

public Type getGenericReturnType() public Type[] getGenericParameterTypes() public Type[] getGenericExceptionTypes() 复制代码

Constructor有以下方法：

public Type[] getGenericParameterTypes() 
复制代码

Type是一个接口，Class实现了Type，Type的其余子接口还有：

• TypeVariable：类型参数，能够有上界，好比：T extends Number
• ParameterizedType：参数化的类型，有原始类型和具体的类型参数，好比：List
• WildcardType：通配符类型，好比：?, ? extends Number, ? super Integer

咱们看一个简单的示例：

public class GenericDemo {
    static class GenericTest<U extends Comparable<U>, V> {
        U u;
        V v;
        List<String> list;

        public U test(List<? extends Number> numbers) {
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        Class<?> cls = GenericTest.class;
        // 类的类型参数
        for (TypeVariable t : cls.getTypeParameters()) {
            System.out.println(t.getName() + " extends " + Arrays.toString(t.getBounds()));
        }

        // 字段 - 泛型类型
        Field fu = cls.getDeclaredField("u");
        System.out.println(fu.getGenericType());

        // 字段 - 参数化的类型
        Field flist = cls.getDeclaredField("list");
        Type listType = flist.getGenericType();
        if (listType instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) listType;
            System.out.println("raw type: " + pType.getRawType() + ",type arguments:"
                    + Arrays.toString(pType.getActualTypeArguments()));
        }

        // 方法的泛型参数
        Method m = cls.getMethod("test", new Class[] { List.class });
        for (Type t : m.getGenericParameterTypes()) {
            System.out.println(t);
        }
    }
}
复制代码

程序的输出为：

U extends [java.lang.Comparable<U>]
V extends [class java.lang.Object]
U
raw type: interface java.util.List,type arguments:[class java.lang.String]
java.util.List<? extends java.lang.Number>
复制代码

代码比较简单，咱们就不赘述了。

慎用反射

反射虽然是灵活的，但通常状况下，并非咱们优先建议的，主要缘由是：

• 反射更容易出现运行时错误，使用显式的类和接口，编译器能帮咱们作类型检查，减小错误，但使用反射，类型是运行时才知道的，编译器无能为力
• 反射的性能要低一些，在访问字段、调用方法前，反射先要查找对应的Field/Method，性能要慢一些

简单的说，若是能用接口实现一样的灵活性，就不要使用反射。

小结

本节介绍了Java中反射相关的主要类和方法，经过入口类Class，能够访问类的各类信息，如字段、方法、构造方法、父类、接口、泛型信息等，也能够建立和操做对象，调用方法等，利用这些方法，能够编写通用的、动态灵活的程序，本节演示了一个简单的通用序列化/反序列化类SimpleMapper。反射虽然是灵活通用的，但它更容易出现运行时错误，因此，能用接口代替的时候，应该尽可能使用接口。

本节介绍的不少类如Class/Field/Method/Constructor均可以有注解，注解究竟是什么呢？

(与其余章节同样，本节全部代码位于 github.com/swiftma/pro…，位于包shuo.laoma.dynamic.c84下)

---

未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，从入门到高级，深刻浅出，老马和你一块儿探索Java编程及计算机技术的本质。用心原创，保留全部版权。