Java编程拾遗『反射』

在大多数场景下，我们在代码编写时，我们一般都知道所要使用的数据的具体类型，会根据类型创建对象，并使用对象的一些属性及方法。但是有些情况下，我们在编写代码时，无法确定要创建对象的具体类型，比如我要编写一个工厂类，通过运行时的输入信息，决定构建一个什么类型的对象，这时候在编译期就无法完成了。而反射就提供了一种机制，在运行时，而非编译时，动态获取类型的信息，比如接口信息、成员信息、方法信息、构造方法信息等，根据这些动态获取到的信息创建对象、访问/修改成员、调用方法等。本篇文章会简单介绍一下Java反射的机制的使用细节，及反射机制的一些应用。

1. Class类

我们都知道，一个.java文件在编译后会形成相应的一个或多个Class文件，这些Class文件中描述了类的各种信息，并且它们最终都需要被加载到虚拟机中才能被运行和使用。事实上，Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成了可以被虚拟机直接使用的Java类型——Class对象。每个已加载的类在内存都有一个对应的Class对象，每个对象都有指向它所属Class对象的引用。

1.1 获取Class对象

获取Class对象就是获取上述可以被虚拟机直接使用的Java类型，在Java中，对应的类是泛型类java.lang.Class。可以通过一下三种方式获取Class对象：

• 调用类的class属性，比如String.class获取的就是String类对应的Class对象
• 调用某个对象的getClass()方法，比如new String().getClass()
• 调用Class.forName(String clazzName)静态方法

1.1.1 <类名>.class

通过类名可以获取类在Java虚拟机中对应的描述类的各种信息的Class对象，如下：

Class<String> cl = String.class;

除了类之外，接口也可以通过这种方式获取描述接口的各种信息的Class对象，如下：

Class<Comparable> cl = Comparable.class;

对于基本数据类型，也可以获取对应的Class对象，Class对象的类型参数为对应的包装类型，如下：

Class<Integer> intCl = int.class;
Class<Character> charCl = char.class;

总之，如果T是任意的Java类型，T.class都可以获取类型对应的类型信息。从这里也可以发现，其实Class对象实际上表示的就是一个类型，而这个类型并不一定是一种类，例如上面讲的int不是类，但是int.class是一个Class类型的对象。依此类推，Java中的各种数组、枚举类、甚至void都可以通过这种方式获取类型信息。

1.1.2 <对象>.getClass()

Java中所有类的父类Object中有一个方法，可以获取对象的类型信息，即getClass()方法，如下：

public final native Class<?> getClass()

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

Employee e;
//……
Class cl = e.getClass();
System.out.println(cl.getName() + " " + e.getName());

Class对象的getName方法，返回该类的名字。上述如果e是一个雇员，将会打印出：

Employee zhuoli

如果e是经理，将会打印出：

Manager zhuoli

如果类在一个包里，包的名字也会作为类名的一部分，如下：

Date d = new Date();
String name = d.getClass().getName(); // name is set to "java.unit.Date"

注意，通过这种方式无法获取基本类型的类型信息，因为getClass()这种方式必须通过对象实例调用。

1.1.3 静态方法Class.forName(clazzName)

Class有一个静态方法forName，可以根据类名直接加载Class，获取Class对象，如下：

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

类名保存在字符串中，就可以通过forName方法获取类名对应类的类型信息。如果类名对应的类不存在，会抛出一个Checked Exception(受检查异常)——ClassNotFoundException。无论合适使用这个方法，都应该提供一个try-catch异常处理器。

1.2 Class方法说明

在Java中，用于提供反射的包java.lang.reflect中有三个重要的类Field、Method和Constructor，分别用来描述类的域、方法和构造器。获取了Class对象后，可以通过Class对象获取上述三个类的实例，通过实例在运行期进行动态调用。

1.2.1 名称信息

它们之间的不同如下所示：

对于getName方法，如果类型是内部类，则使用“$”符号进行连接。如果类型是数组，则使用“[”来表示，数组是几维，“[”就有几个，对于引用类型数组最后会多一个“;”。getTypeName与getName的区别是在数组类型的处理上，如果是数组类型，会转换成友好的展示方式，如果非数组类型，则与getName返回相同。

1.2.2 成员变量信息

通过Class对象除了可以获取类型名称信息，还可以获取类型所表示类的成员变量。

1.2.3 方法信息

通过Class对象获取Class对象对应类的内部方法信息，如下：

1.2.4 构造器信息

通过Class对象获取Class对象对应类的构造器信息，如下：

1.2.5 类注解信息

通过Class对象获取Class对象对应类的注解信息，如下：

1.2.5 类信息

1.2.6 类修饰符信息

2. 反射工具介绍

Java API中，包java.util.reflect下提供了很多用于反射的类，可以方便的使用上述成员信息、构造器信息、方法信息，分别对应包下的三个类Field、Constructor和Method。

2.1 Field类

上面讲过，可以通过Class对象获取对应类的成员变量，并且不难发现返回值类型为java.util.reflect包下的Field。通过Field对象可以对改成员变量进行设置访问权限、获取成员变量值、设置成员变量值等操作。下面看一下Field类的主要方法：

调用示例：

@Getter
@Setter
@AllArgsConstructor
public class Father {
    private String name;

    private Integer age;
}

@Getter
@Setter
@ToString
public class Son extends Father {
    private static final String CONSTANT_STRING = "constant";

    private Float score;

    private boolean isPass;

    public Son(String name, Integer age, Float score, Boolean isPass) {
        super(name, age);
        this.score = score;
        this.isPass = isPass;
    }
}

public static void main(String[] args) {
    
    Father son = new Son("zhuoli", 18, 95.0f, true);
    Field[] fields = son.getClass().getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        try {
            System.out.println(field.getName()+" - "+field.get(son));
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    System.out.println("-------------------");
    try {
        Field isPassField = son.getClass().getDeclaredField("isPass");
        isPassField.setAccessible(true);
        boolean isPass = isPassField.getBoolean(son);
        System.out.println("before change, isPass: " + isPass);
        isPassField.setBoolean(son, false); //设置对象son的isPass成员变量的值为false
        System.out.println(son);

        System.out.println("-------------------");
        Field scoreField = son.getClass().getDeclaredField("score");
        scoreField.setAccessible(true);
        Float score = (Float) scoreField.get(son);
        System.out.println("before change, score: " + score);
        scoreField.set(son, 99.9f); //设置对象son的score成员变量的值为99.9f
        System.out.println(son);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行结果：

CONSTANT_STRING - constant
score - 95.0
isPass - true
-------------------
before change, isPass: true
Son(score=95.0, isPass=false)
-------------------
before change, score: 95.0
Son(score=99.9, isPass=false)

2.2 Constructor类

上面讲过通过Class对象可以获取对应类的构造器信息，返回值类型为Constructor。通过Constructor实例，可以构造对象实例。同Field类相似，Constructor类中也有getName、getModifiers等方法，语言也是相似的。

下面重点看一下newInstance方法，如下：

public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException

可以通过如下方式调用：

try {
    Constructor<Son> constructor = Son.class.getDeclaredConstructor(String.class, Integer.class, Float.class, Boolean.class);
    Son son1 = constructor.newInstance("Michael", 19, 96.8f, true);
    System.out.println(son1);
} catch (Exception e) {
    e.printStackTrace();
}

运行结果：

Son(score=96.8, isPass=true)

说明成功通过Construtor构建了一个Son实例。

2.3 Method类

Method类的引用变量可以指向上面通过Class对象获取的成员方法信息，Method实例可以用来动态代用调用方法。首先看一下Method类中的常用方法：

invoke方法声明如下：

public Object invoke(Object obj, Object... args)
    throws IllegalAccessException, IllegalArgumentException,
       InvocationTargetException

可以通过如下方式调用：

try {
    Method method = Son.class.getMethod("getAge", null);
    Integer age = (Integer) method.invoke(son, null);
    System.out.println(age);
} catch (Exception e) {
    e.printStackTrace();
}

运行结果：

18

说明通过反射，成功调用了getAge方法。除了反射共有方法，还可以通过反射调用类的私有方法，假如getAge是私有方法，则可以通过如下方式反射调用：

try {
    Method method = Son.class.getMethod("getAge", null);
    method.setAccessible(true); //设置访问权限为可访问
    Integer age = (Integer) method.invoke(son, null);
    System.out.println(age);
} catch (Exception e) {
    e.printStackTrace();
}

最后讲一下关于修饰符Modifiers的问题，首先在Son类中添加一个静态方法，如下：

public static void modifiersTestMethod(String info) {
    System.out.println(info);
}

可以通过如下方式解析修饰符信息：

try {
    Method method = Son.class.getMethod("modifiersTestMethod", String.class);
    method.invoke(null, "test test test!");

    int modifierCode = method.getModifiers();
    System.out.println(Modifier.toString(modifierCode));
    System.out.println("isPublic: " + Modifier.isPublic(modifierCode));
    System.out.println("isStatic: " + Modifier.isStatic(modifierCode));
    System.out.println("isFinal: " + Modifier.isFinal(modifierCode));
    System.out.println("isVolatile: " + Modifier.isVolatile(modifierCode));
} catch (Exception e) {
    e.printStackTrace();
}

运行结果：

test test test!
public static
isPublic: true
isStatic: true
isFinal: false
isVolatile: false

2.4 Array类

除了上面讲的Field、Construtor和Method类，java.lang.reflect包中还有一个比较重要的类——Array，用于数组的一些反射支持，以便于统一处理多种类型的数组。

回想一下，工具类java.util.Arrays类中有一个方法copyOf，声明如下

public static <T> T[] copyOf(T[] original, int newLength)

可以实现数组复制，如果newLength大于原数组original长度，还可以实现对数组扩容的效果。现在我们也想写一个功能类似的数组扩容的通用方法，扩容10%，同时不希望手动去写那些扩展拷贝元素的代码。于是首先我们首先想到的是使用Object数组，实现通用的效果，然后通过System.arrayCopy代替手工的拷贝元素的操作，如下：

public static Object[] badArrayGrow(Object[] array) {
    int length = array.length;
    int newLength = length * 11 / 10;
    Object[] newArray = new Object[newLength];

    System.arraycopy(array, 0, newArray, 0, length);
    return newArray;
}

好像看起来是完全没问题的，使用时在讲Object数组转换成目标数组，如下：

Integer[] array = new Integer[10];
array[0] = 1;
array[1] = 2;
array[2] = 3;

Integer[] newArray1 = (Integer[]) ArrayUtil.badArrayGrow(array);
System.out.println(newArray1.length);

编译没有任何问题，但是在运行时，报错了，报错信息如下：

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

因为Java数组会记住每个元素的类型，即创建数组时new表达式中使用的元素类型。将一个Integer[]临时转换成Object[]数组，然后再把它转换回来是可以的，但是一个从开始就是Object[]的数组是永远不能转换Integer[]数组。所以这种方式显然是不能达到扩容效果的，为了能够实现通用的数组代码，需要能够创建与原数组类型相同的新数组，这时候就可以通过上述java.lang.reflect包中的Array类提供的newInstance方法，构建特定类型的数组。所以对扩容方法进行改进，如下：

public static Object goodArrayGrow(Object[] array) {
    int newLength = array.length * 11 / 10;
    return Array.newInstance(array.getClass().getComponentType(), newLength);
}

如下调用：

Integer[] newArray2 = (Integer[]) ArrayUtil.goodArrayGrow(array);
System.out.println(newArray2.length);

运行结果：

11

扩容成功了，但是可以发现另一个问题，这个方法只能对对象类型数组扩容，对于基本类型数组，是无法使用的，一个基本类型数组时不能赋值给Object[]类型引用的。所以又对方法进行了改造，如下：

public static Object ultimateArrayGrow(Object array) {
    Class<?> clazz = array.getClass();
    if (!clazz.isArray()) {
        throw new RuntimeException("src object is not an array");
    }
    Class<?> componentClazz = clazz.getComponentType();
    int length = Array.getLength(array);
    int newLength = length * 11 / 10;
    Object newArray = Array.newInstance(componentClazz, newLength);
    System.arraycopy(array, 0, newArray, 0 , length);
    return newArray;
}

方法形参定义为Object而不是Object[]，这样就可以接受基本类型数组实参了。同时在方法中添加数组类型校验，保证传入的参数为数组。特别讲一下，Class对象的getComponentType可以获取数组元素类型，Array.getLength方法可以获取数组长度，数组的这两个属性并不在一个类中，有点奇怪。如果不考虑基础类型数组，还可以使用泛型方法实现扩容，如下：

public static <T> T[] arrayGrow(T[] array) {
    int length = array.length;
    int newLength = length * 11 / 10;

    Object newArray = Array.newInstance(array.getClass().getComponentType(), newLength);
    System.arraycopy(array, 0, newArray, 0, length);
    return (T[]) newArray;
}

最后讲一下，其实Arrays.copyOf方法，也是通过Array.newInstance实现的，如下：

public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

除了上述Field、Construtor、Method、Array类，java.lang.reflect包中还有很多反射相关的类，这里不再详细介绍了，上述四个类是反射中最常用的四个类，掌握上述四个基本可以灵活的使用反射了。但是要注意的是，反射虽然是灵活的，更容易出现运行时错误，使用显式的类和接口，编译器能帮我们做类型检查，减少错误，编写反射代码时，需要更加谨慎。

参考链接：

1. Class类 getName()、getCanonicalName()、getSimpleName()、getTypeName() 方法的异同
2. Java反射获取类和对象信息全解析
3. 反射机制与原理笔记
4. 《Java核心技术 卷Ⅰ》