Java反射(Reflection)

Free Talk

本篇文章会从Class类、访问字段等角度深度理解Java反射的特性。
同时文章基本上都是直接照搬廖雪峰的反射博客,他真的写的太好了,通俗易懂,我有种班门弄斧的感觉,甚至产生放弃写博客的念头。
廖雪峰博客

简述

Java的反射是指程序在运行期间可以拿到一个对象的所有信息。
正常情况下,如果我们要调用一个对象的方法,或者访问一个对象的字段,通常会传入对象实例:

1
2
3
4
5
6
7
8
// Main.java
import com.itranswarp.learnjava.Person;

public class Main {
String getFullName(Person p) {
return p.getFirstName() + " " + p.getLastName();
}
}

但是,如果不能获得Person类,只有一个Object实例,比如这样:

1
2
3
String getFullName(Object obj) {
return ???
}

怎么办?有童鞋会说:强制转型啊!

1
2
3
4
String getFullName(Object obj) {
Person p = (Person) obj;
return p.getFirstName() + " " + p.getLastName();
}

强制转型的时候,你会发现一个问题:编译上面的代码,仍然需要引用Person类。不然,去掉import语句,你看能不能编译通过?

所以,反射是为了解决在运行期,对某个实例一无所知的情况下,如何调用其方法。

Class类

JVM在执行过程中动态记载class类,JVM在第一次读取到一种class类型时,将其加载进内存中。
每加载一种class,JVM就为其创建一个Class类型的实例,并关联起来。

这里的Class类型是一个名叫Classclass:

1
2
3
public final class Class {
private Class() {}
}

通过Class实例获取class信息的方法称为反射(Reflection)。
获取Class实例的方法有以下三种。

class方法

直接通过一个class的静态变量class获取:

1
Class cls = String.class;

getClass()方法

如果我们有一个实例变量,可以通过该实例变量提供的getClass()方法获取:

1
2
String s = "Hello";
Class cls = s.getClass();

Class.forName()方法

如果知道一个class的完整类名,可以通过静态方法Class.forName()获取:

1
Class cls = Class.forName("java.lang.String");

因为Class实例在JVM中是唯一的,所以,上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例:

1
2
3
4
5
6
Class cls1 = String.class;

String s = "Hello";
Class cls2 = s.getClass();

boolean sameClass = cls1 == cls2; // true

访问字段

对任意的一个Object实例,只要我们获取了它的Class,就可以获取它的一切信息。
我们先看看如何通过Class实例获取字段信息。Class类提供了以下几个方法来获取字段:

  • Field getField(name):根据字段名获取某个public的field(包括父类)

    即获取name所对应的Public的字段

  • Field getDeclaredField(name):根据字段名获取当前类的某个field(不包括父类)

    即获取name所对应的字段,可以是Public,也可以是Private

  • Field[] getFields():获取所有public的field(包括父类)
  • Field[] getDeclaredFields():获取当前类的所有field(不包括父类)

实例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Main {
public static void main(String[] args) throws Exception {
// 上面提到第一种的class方法获取Class实例
Class stdClass = Student.class;
// 获取public字段"score":
System.out.println(stdClass.getField("score"));
// 获取继承的public字段"name":
System.out.println(stdClass.getField("name"));
// 获取private字段"grade":
System.out.println(stdClass.getDeclaredField("grade"));
}
}

class Student extends Person {
public int score;
private int grade;
}

class Person {
public String name;
}

上述代码首先获取StudentClass实例,然后,分别获取public字段、继承的public字段以及private字段,打印出的Field类似:

1
2
3
public int Student.score
public java.lang.String Person.name
private int Student.grade

一个Field对象包含了一个字段的所有信息:

  • getName():返回字段名称,例如,"name"
  • getType():返回字段类型,也是一个Class实例,例如,String.class
  • getModifiers():返回字段的修饰符,它是一个int,不同的bit表示不同的含义。

String类的value字段为例,它的定义是:

1
2
3
public final class String {
private final byte[] value;
}

我们用反射获取该字段的信息,代码如下:

1
2
3
4
5
6
7
8
9
Field f = String.class.getDeclaredField("value");
f.getName(); // "value"
f.getType(); // class [B 表示byte[]类型
int m = f.getModifiers();
Modifier.isFinal(m); // true
Modifier.isPublic(m); // false
Modifier.isProtected(m); // false
Modifier.isPrivate(m); // true
Modifier.isStatic(m); // false

获取字段值

利用反射拿到字段的一个Field实例只是第一步,我们还可以拿到一个实例对应的该字段的值。

例如,对于一个Person实例,我们可以先拿到name字段对应的Field,再获取这个实例的name字段的值:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// reflection
import java.lang.reflect.Field;
public class Main {

public static void main(String[] args) throws Exception {
// 上面提到的第二种方法getClass()获取Class实例
Object p = new Person("Xiao Ming");
Class c = p.getClass();
Field f = c.getDeclaredField("name");
Object value = f.get(p);
System.out.println(value); // "Xiao Ming"
}
}

class Person {
private String name;

public Person(String name) {
this.name = name;
}
}

上述代码先获取Class实例,再获取Field实例,然后,用Field.get(Object)获取指定实例的指定字段的值。

运行代码,如果不出意外,会得到一个IllegalAccessException,这是因为name被定义为一个private字段,正常情况下,Main类无法访问Person类的private字段。要修复错误,可以将private改为public,或者,在调用Object value = f.get(p);前,先写一句:

1
f.setAccessible(true);

调用Field.setAccessible(true)的意思是,别管这个字段是不是public,一律允许访问。

可以试着加上上述语句,再运行代码,就可以打印出private字段的值。

有童鞋会问:如果使用反射可以获取private字段的值,那么类的封装还有什么意义?

答案是正常情况下,我们总是通过p.name来访问Personname字段,编译器会根据publicprotectedprivate决定是否允许访问字段,这样就达到了数据封装的目的。

而反射是一种非常规的用法,使用反射,首先代码非常繁琐,其次,它更多地是给工具或者底层框架来使用,目的是在不知道目标实例任何信息的情况下,获取特定字段的值。

此外,setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager,那么它会根据规则进行检查,有可能阻止setAccessible(true)。例如,某个SecurityManager可能不允许对javajavax开头的package的类调用setAccessible(true),这样可以保证JVM核心库的安全。

设置字段值

通过Field实例既然可以获取到指定实例的字段值,自然也可以设置字段的值。

设置字段值是通过Field.set(Object, Object)实现的,其中第一个Object参数是指定的实例,第二个Object参数是待修改的值。示例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// reflection
import java.lang.reflect.Field;

public class Main {

public static void main(String[] args) throws Exception {
// 创建Person对象实例
Person p = new Person("Xiao Ming");
// 获取实例name
System.out.println(p.getName()); // "Xiao Ming"
// 通过getClass()获取Class实例
Class c = p.getClass();
// 通过getDeclaredField(name)获取Field实例
Field f = c.getDeclaredField("name");
// 对于private字段,调用setAccessible()来允许访问
f.setAccessible(true);
// 使用Field.set(obj,obj)来修改实例的字段值
f.set(p, "Xiao Hong");
System.out.println(p.getName()); // "Xiao Hong"
}
}

class Person {
private String name;

public Person(String name) {
this.name = name;
}

public String getName() {
return this.name;
}
}

运行上述代码,打印的name字段从Xiao Ming变成了Xiao Hong,说明通过反射可以直接修改字段的值。

同样的,修改非public字段,需要首先调用setAccessible(true)

小结

  1. Java的反射API提供的Field类封装了字段的所有信息:
  2. 通过Class实例的方法可以获取Field实例:getField()getFields()getDeclaredField()getDeclaredFields()
  3. 通过Field实例可以获取字段信息:getName()getType()getModifiers()
  4. 通过Field实例可以读取或设置某个对象的字段,如果存在访问限制,要首先调用setAccessible(true)来访问非public字段。
  5. 通过反射读写字段是一种非常规方法,它会破坏对象的封装。

调用方法

我们已经能通过Class实例获取所有Field对象,同样的,可以通过Class实例获取所有Method信息。Class类提供了以下几个方法来获取Method:

  • Method getMethod(name, Class...):获取某个publicMethod(包括父类)
  • Method getDeclaredMethod(name, Class...):获取当前类的某个Method(不包括父类)
  • Method[] getMethods():获取所有publicMethod(包括父类)
  • Method[] getDeclaredMethods():获取当前类的所有Method(不包括父类)

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Main {
public static void main(String[] args) throws Exception {
Class stdClass = Student.class;
// 获取public方法getScore,参数为String:
System.out.println(stdClass.getMethod("getScore", String.class));
// 获取继承的public方法getName,无参数:
System.out.println(stdClass.getMethod("getName"));
// 获取private方法getGrade,参数为int:
System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));
}
}

class Student extends Person {
public int getScore(String type) {
return 99;
}
private int getGrade(int year) {
return 1;
}
}

class Person {
public String getName() {
return "Person";
}
}

上述代码首先获取StudentClass实例,然后,分别获取public方法、继承的public方法以及private方法,打印出的Method类似:

1
2
3
public int Student.getScore(java.lang.String)
public java.lang.String Person.getName()
private int Student.getGrade(int)

一个Method对象包含一个方法的所有信息:

  • getName():返回方法名称,例如:"getScore"
  • getReturnType():返回方法返回值类型,也是一个Class实例,例如:String.class;
  • getParameterTypes():返回方法的参数类型,是一个Class数组,例如:{String.class, int.class}
  • getModifiers():返回方法的修饰符,它是一个int,不同的bit表示不同的含义。

小结

Java的反射API提供的Method对象封装了方法的所有信息:

  1. 通过Class实例的方法可以获取Method实例:getMethod()getMethods()getDeclaredMethod()getDeclaredMethods()
  2. 通过Method实例可以获取方法信息:getName()getReturnType()getParameterTypes()getModifiers()
  3. 通过Method实例可以调用某个对象的方法:Object invoke(Object instance, Object... parameters)
  4. 通过设置setAccessible(true)来访问非public方法;
  5. 通过反射调用方法时,仍然遵循多态原则。