序言
通过 Java 的反射机制，小伙伴们可以更深入地控制程序的运行过程。例如，在程序运行时由用户输入一个类名，然后动态获取该类拥有的构造、属性和方法，甚至调用任意类的任意方法。
一、基本概念
1.1 Java反射机制是什么？
Java 反射机制是 Java 语言的一个重要特性，在学习 Java 反射机制前，小伙伴们应该先了解两个概念：编译期和运行期。编译期是指把源码交给编译器编译成计算机可以执行的文件的过程。在 Java 中也就是把 Java 代码编成 class 文件的过程。编译期只是做了一些翻译功能，并没有把代码放在内存中运行起来，而只是把代码当成文本进行操作，比如检查错误。运行期是把编译后的文件交给计算机执行，直到程序运行结束。也就是说，所谓运行期就把在磁盘中的代码放到内存中执行起来。
Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；而对于任意一个对象，都能够调用它的任意方法和属性，这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。简单来说，反射机制指的是程序在运行时能够获取自身的信息。在 Java 中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。
Java 反射机制在服务器程序和中间件程序中得到了广泛运用。在服务器端，往往需要根据客户的请求，动态调用某一个对象的特定方法。此外，在 ORM 中间件的实现中，运用 Java 反射机制可以读取任意一个 JavaBean 的所有属性，或者给这些属性赋值。
1.2 反射机制功能
Java 反射机制主要提供了以下功能，这些功能都位于java.lang.reflect包。
- 在运行时判断任意一个对象所属的类。
- 在运行时构造任意一个类的对象。
- 在运行时判断任意一个类所具有的成员变量和方法。
- 在运行时调用任意一个对象的方法。
- 生成动态代理。
要想知道一个类的属性和方法，必须先获取到该类的字节码文件对象。获取类的信息时，使用的就是 Class 类中的方法。所以，先要获取到每一个字节码文件（.class）对应的 Class 类型的对象。众所周知，所有 Java 类均继承了 Object 类，在 Object 类中定义了一个 getClass() 方法，该方法返回同一个类型为 Class 的对象。例如，下面的示例代码：
java
// label1为 JLabel 类的对象
Class labelCls = label1.getClass();利用 Class 类的对象 labelCls 可以访问 labelCls 对象的描述信息、JLabel 类的信息以及基类 Object 的信息。下表列出了通过反射可以访问的信息：
| 类型 | 访问方法 | 返回值类型 | 说明 |
|---|---|---|---|
| 包路径 | getPackage() | Package对象 | 获取该类的存放路径 |
| 类名称 | getName() | String对象 | 获取该类的名称 |
| 继承类 | getSuperclass() | Class对象 | 获取该类继承的类 |
| 实现接口 | getlnterfaces() | Class型数组 | 获取该类实现的所有接口 |
| 构造方法 | getConstructors() | Constructor型数组 | 获取所有权限为public的构造方法 |
| getDeclaredContruectors() | Constructor对象 | 获取当前对象的所有构造方法 | |
| 方法 | getMethods() | Methods型数组 | 获取所有权限为public的方法 |
| getDeclaredMethods() | Methods对象 | 获取当前对象的所有方法 | |
| 成员变量 | getFields() | Field型数组 | 获取所有权限为public的成员变量 |
| getDeclareFileds() | Field对象 | 获取当前对象的所有成员变量 | |
| 内部类 | getClasses() | Class型数组 | 获取所有权限为public的内部类 |
| getDeclaredClasses() | Class型数组 | 获取所有内部类 | |
| 内部类的声明类 | getDeclaringClass() | Class对象 | 如果该类为内部类，则返回它的成员类，否则返回null |
如上表所示，在调用 getFields() 和 getMethods() 方法时将会依次获取权限为 public 的字段和变量，然后将包含从超类中继承到的成员变量和方法。而通过 getDeclareFields() 和 getDeclareMethod() 只是获取在本类中定义的成员变量和方法。
1.3 反射机制的优缺点
- 优点：
- 通过 Java 反射机制能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性。
- 可以与 Java 动态编译相结合，可以实现无比强大的功能。
- 对于 Java 这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。
- 缺点：
- 反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射。
- 反射调用方法时可以忽略权限检查，获取这个类的私有方法和属性，因此可能会破坏类的封装性而导致安全问题。
因此，Java 反射机制在一般的 Java 应用开发中很少使用，即便是 Java EE 阶段也很少使用。
二、Java反射机制API
实现 Java 反射机制的类都位于 java.lang.reflect 包中，java.lang.Class 类是 Java 反射机制 API 中的核心类。本小节将从这两个方面讲解 Java 反射机制 API。
2.1 java.lang.Class 类
java.lang.Class 类是实现反射的关键所在，存在于JDK的java.lang包中，可以通过它获取类的构造函数、方法、字段等信息。Class 类的一个实例表示 Java 的一种数据类型，表示某个类加载后在堆中的对象，包括类、接口、枚举、注解（Annotation）、数组、基本数据类型和 void。Class 没有公有的构造方法，Class 实例是由 JVM 在类加载时自动创建的。在代码中获得 Class 实例可以通过如下代码实现：
java
// 1. 通过类型class静态变量
Class clz1 = String.class;
String str = "Hello";
// 2. 通过对象的getClass()方法
Class clz2 = str.getClass();每一种类型包括类和接口等，都有一个 class 静态变量可以获得 Class 实例。另外，每一个对象都有 getClass() 方法可以获得 Class 实例，该方法是由 Object 类提供的实例方法。Class 类提供了很多方法可以获得运行时对象的相关信息，下面的示例代码展示了其中一些方法。
java
public class ReflectionTest01 {
public static void main(String[] args) {
// 1、获得Class实例
// 1.1 通过类型class静态变量
Class clz1 = String.class;
String str = "Hello";
// 1.2 通过对象的getClass()方法
Class clz2 = str.getClass();
// 2、获得int类型Class实例
Class clz3 = int.class;
// 3、获得Integer类型Class实例
Class clz4 = Integer.class;
System.out.println("clz2类名称：" + clz2.getName());
System.out.println("clz2是否为接口：" + clz2.isInterface());
System.out.println("clz2是否为数组对象：" + clz2.isArray());
System.out.println("clz2父类名称：" + clz2.getSuperclass().getName());
System.out.println("clz2是否为基本类型：" + clz2.isPrimitive());
System.out.println("clz3是否为基本类型：" + clz3.isPrimitive());
System.out.println("clz4是否为基本类型：" + clz4.isPrimitive());
}
}2.2 java.lang.reflect 包
java.lang.reflect 包提供了反射中用到类，主要的类说明如下表所示：
| 类 | 类说明 |
|---|---|
| Constructor | 提供类的构造方法信息 |
| Field | 提供类或接口中成员变量信息 |
| Method | 提供类或接口成员方法信息 |
| Array | 提供动态创建和访问Java数组的方法 |
| Modifier | 提供类和成员访问修饰符信息 |
2.2.1 java.lang.reflect.Constructor
java.lang.reflect.Constructor 表示一个类的构造函数，可以通过它创建对象。在Java反射机制中，Constructor 对象表示一个类的构造函数，可以用来创建该类的实例对象。通过下列任意一个方法访问能够动态获取对象构造方法的信息，如下所示：
java
Constructor<?>[] getConstructors()
// 获取该类的指定构造函数
Constructor<?>[] getConstructor(Class<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
// 获取该类的指定构造函数，不考虑其访问权限
Constructor<?>[] getDeclaredConstructor(Class<?>... parameterTypes)使用 Constructor 类可以通过反射机制来创建一个类的实例对象，可以方便地调用私有构造函数等。创建的每个 Constructor 对象表示一个构造方法，然后利用 Constructor 对象的方法操作构造方法。Constructor 类的常用方法如下表所示：
| 方法名称 | 说明 |
|---|---|
| isVarArgs() | 查看该构造方法是否允许带可变数量的参数，如果允许，返回true，否则返回false |
| getParameterTypes() | 按照声明顺序以Class数组的形式获取该构造方法各个参数的类型 |
| getExceptionTypes() | 以Class数组的形式获取该构造方法可能抛出的异常类型 |
| newInstance(Object... initargs) | 通过该构造方法利用指定参数创建一个该类型的对象，如果未设置参数则表示采用默认无参的构造方法 |
| setAccessiable(boolean flag) | 如果该构造方法的权限为private，默认为不允许通过反射利用netlnstance()方法创建对象。 如果先执行该方法，并将入口参数设置为true，则允许创建对象 |
| getModifiers() | 获得可以解析出该构造方法所采用修饰符的整数 |
下面通过一个案例来演示如何调用 Constructor 类的方法获取构造方法的信息。
-
首先创建一个 Book 类表示图书信息。在该类中声明一个 String 型变量表示图书名称，两个 int 型变量分别表示图书编号和价格，并提供 3 个构造方法。如下：
javapublic class Book { // 图书名称 String name; // 图书编号 int id; // 图书价格 int price; // 空的构造方法 private Book() { } // 带两个参数的构造方法 protected Book(String name, int id) { this.name = name; this.id = id; } // 带可变参数的构造方法 public Book(String... strings) throws NumberFormatException { if (0 < strings.length){ id = Integer.valueOf(strings[0]); } if (1 < strings.length){ price = Integer.valueOf(strings[1]); } } // 输出图书信息 public void print() { System.out.println("name=" + name); System.out.println("id=" + id); System.out.println("price=" + price); } } -
编写测试类 Test01，在该类的 main() 方法中通过反射访问 Book 类中的所有构造方法，并将该构造方法是否带可变类型参数、入口参数类型和可能拋出的异常类型信息输出到控制台。
javapublic class Test01 { public static void main(String[] args) { // 获取动态类Book Class book = Book.class; // 获取Book类的所有构造方法 Constructor[] declaredContructors = book.getDeclaredConstructors(); // 遍历所有构造方法 for (int i = 0; i < declaredContructors.length; i++) { Constructor con = declaredContructors[i]; // 判断构造方法的参数是否可变 System.out.println("查看是否允许带可变数量的参数：" + con.isVarArgs()); System.out.println("该构造方法的入口参数类型依次为："); // 获取所有参数类型 Class[] parameterTypes = con.getParameterTypes(); for (int j = 0; j < parameterTypes.length; j++) { System.out.println(" " + parameterTypes[j]); } System.out.println("该构造方法可能拋出的异常类型为："); // 获取所有可能拋出的异常类型 Class[] exceptionTypes = con.getExceptionTypes(); for (int j = 0; j < exceptionTypes.length; j++) { System.out.println(" " + parameterTypes[j]); } // 创建一个未实例化的Book类实例 Book book1 = null; while (book1 == null) { try { // 如果该成员变量的访问权限为private，则拋出异常 if (i == 1) { // 通过执行带两个参数的构造方法实例化book1 book1 = (Book) con.newInstance("Java 教程", 10); } else if (i == 2) { // 通过执行默认构造方法实例化book1 book1 = (Book) con.newInstance(); } else { // 通过执行可变数量参数的构造方法实例化book1 Object[] parameters = new Object[] { new String[] { "100", "200" } }; book1 = (Book) con.newInstance(parameters); } } catch (Exception e) { System.out.println("在创建对象时拋出异常，下面执行 setAccessible() 方法"); con.setAccessible(true); // 设置允许访问 private 成员 } } book1.print(); System.out.println("=============================\n"); } } } -
运行测试类 Test01。
2.2.2 java.lang.reflect.Method
java.lang.reflect.Method 表示一个类的方法，可以通过它调用类的方法。Method类是用于表示类或接口的方法的反射机制类。它包含有关方法名称，参数类型，返回类型，访问修饰符等信息的元数据。通过下列任意一个方法访问能够动态获取一个对象方法的信息，如下所示：
java
Method[] getMethods()
// 返回具有指定名称和参数类型的公共方法
Method getMethods(String name,Class<?> ...parameterTypes)
Method[] getDeclaredMethods()
// 返回具有指定名称和参数类型的方法，无论是否为公共方法
Method getDeclaredMethods(String name,Class<?>...parameterTypes)使用Method类，可以在运行时动态地调用类的方法，而无需在编译时知道类的确切类型。一旦获得了Method对象，就可以使用invoke()方法调用它来执行方法，需要提供目标对象和方法的参数。Method 类的常用方法如下表所示：
| 方法名称 | 说明 |
|---|---|
| getName() | 获取该方法的名称 |
| getParameterType() | 按照声明顺序以 Class 数组的形式返回该方法各个参数的类型 |
| getReturnType() | 以 Class 对象的形式获得该方法的返回值类型 |
| getExceptionTypes() | 以 Class 数组的形式获得该方法可能抛出的异常类型 |
| invoke(Object obj,Object...args) | 利用 args 参数执行指定对象 obj 中的该方法，返回值为 Object 类型 |
| isVarArgs() | 查看该方法是否允许带有可变数量的参数，如果允许返回 true，否则返回 false |
| getModifiers() | 获得可以解析出该方法所采用修饰符的整数。 默认修饰符是0，public是1，private是2，protected是4，static是8，final是16 |
下面通过一个案例来演示如何调用 Method 类的方法获取动态类中方法的信息。
-
首先创建一个 Book1 类，并编写 4 个具有不同作用域的方法，代码如下：
javapublic class Book1 { // static 作用域方法 static void staticMethod() { System.out.println("执行staticMethod()方法"); } // public 作用域方法 public int publicMethod(int i) { System.out.println("执行publicMethod()方法"); return 100 + i; } // protected 作用域方法 protected int protectedMethod(String s, int i) throws NumberFormatException { System.out.println("执行protectedMethod()方法"); return Integer.valueOf(s) + i; } // private 作用域方法 private String privateMethod(String... strings) { System.out.println("执行privateMethod()方法"); StringBuffer sb = new StringBuffer(); for (int i = 0; i < sb.length(); i++) { sb.append(strings[i]); } return sb.toString(); } } -
编写测试类 Test02，在该类的 main() 方法中通过反射访问 Book1 类中的所有方法，并将该方法是否带可变类型参数、入口参数类型和可能拋出的异常类型信息输出到控制台，代码如下：
javapublic class Test02 { public static void main(String[] args) { // 获取动态类Book1 Book1 book = new Book1(); Class class1 = book.getClass(); // 获取Book1类的所有方法 Method[] declaredMethods = class1.getDeclaredMethods(); for (int i = 0; i < declaredMethods.length; i++) { Method method = declaredMethods[i]; System.out.println("方法名称为：" + method.getName()); System.out.println("方法是否带有可变数量的参数：" + method.isVarArgs()); System.out.println("方法的参数类型依次为："); // 获取所有参数类型 Class[] methodType = method.getParameterTypes(); for (int j = 0; j < methodType.length; j++) { System.out.println(" " + methodType[j]); } // 获取返回值类型 System.out.println("方法的返回值类型为：" + method.getReturnType()); System.out.println("方法可能抛出的异常类型有："); // 获取所有可能抛出的异常 Class[] methodExceptions = method.getExceptionTypes(); for (int j = 0; j < methodExceptions.length; j++) { System.out.println(" " + methodExceptions[j]); } boolean isTurn = true; while (isTurn) { try { // 如果该成员变量的访问权限为private，则抛出异常 isTurn = false; if (method.getName().equals("staticMethod")) { // 调用没有参数的方法 method.invoke(book); } else if (method.getName().equals("publicMethod")) { // 调用一个参数的方法 System.out.println("publicMethod(10)的返回值为：" + method.invoke(book, 10)); } else if (method.getName().equals("protectedMethod")) { // 调用两个参数的方法 System.out.println("protectedMethod(\"10\",15)的返回值为：" + method.invoke(book, "10", 15)); } else if (method.getName().equals("privateMethod")) { // 调用可变数量参数的方法 Object[] parameters = new Object[] { new String[] { "J", "A", "V", "A" } }; System.out.println("privateMethod()的返回值为：" + method.invoke(book, parameters)); } } catch (Exception e) { System.out.println("在设置成员变量值时抛出异常，下面执行setAccessible()方法"); method.setAccessible(true); // 设置为允许访问private方法 isTurn = true; } } System.out.println("=============================\n"); } } } -
运行测试类 test02，程序将会依次动态访问 Book1 类中的所有方法。
2.2.3 java.lang.reflect.Field
java.lang.reflect.Field 表示一个类的字段，可以通过它获取和设置类的属性值。Field类代表类或接口的字段，即类或接口中的变量。Field类提供了访问和操作字段的方法，包括获取字段的名称、类型、修饰符、值等。通过下列任意一个方法访问成员变量时将返回 Field 类型的对象或数组，如下所示：
java
Field[] getFields()
// 获取该类的指定公共字段
Field getField(String name)
Field[] getDeclaredFields()
// 获取该类的指定字段，不考虑其访问权限
Field getDeclaredField(String name)Field类是通过Java反射机制来实现的，反射机制是一种在运行时分析和操作类、接口、方法、字段等程序构件的机制。使用反射机制，可以在运行时获取一个类的信息，包括其方法、字段、注解、泛型类型等，并可以动态地创建对象、调用方法、访问字段等。Field 类的常用方法如下表所示：
| 方法名称 | 说明 |
|---|---|
| getName() | 获得该成员变量的名称 |
| getType() | 获取表示该成员变量的 Class 对象 |
| get(Object obj) | 获得指定对象 obj 中成员变量的值，返回值为 Object 类型 |
| set(Object obj, Object value) | 将指定对象 obj 中成员变量的值设置为 value |
| getlnt(0bject obj) | 获得指定对象 obj 中成员类型为 int 的成员变量的值 |
| setlnt(0bject obj, int i) | 将指定对象 obj 中成员变量的值设置为 i |
| setFloat(Object obj, float f) | 将指定对象 obj 中成员变量的值设置为 f |
| getBoolean(Object obj) | 获得指定对象 obj 中成员类型为 boolean 的成员变量的值 |
| setBoolean(Object obj, boolean b) | 将指定对象 obj 中成员变量的值设置为 b |
| getFloat(Object obj) | 获得指定对象 obj 中成员类型为 float 的成员变量的值 |
| setAccessible(boolean flag) | 此方法可以设置是否忽略权限直接访问 private 等私有权限的成员变量 |
| getModifiers() | 获得可以解析出该方法所采用修饰符的整数。 默认修饰符是0，public是1，private是2，protected是4，static是8，final是16 |
下面通过一个案例来演示如何调用 Field 类的方法获取动态类中各个成员的信息。
-
首先创建一个 Book2 类，在该类中依次声明一个 String、int、float 和 boolean 类型的成员，并设置不同的访问作用域，代码如下：
javapublic class Book2 { String name; public int id; private float price; protected boolean isLoan; } -
编写测试类 Test03，在该类的 main() 方法中通过反射访问 Book2 类中的所有成员，并将该成员的名称和类型信息输出到控制台，代码如下：
javaimport java.lang.reflect.Constructor; import java.lang.reflect.Field; public class Test03 { public static void main(String[] args) { Book2 book = new Book2(); // 获取动态类Book2 Class class1 = book.getClass(); // 获取Book2类的所有成员 Field[] declaredFields = class1.getDeclaredFields(); // 遍历所有的成员 for(int i = 0;i < declaredFields.length;i++) { // 获取类中的成员变量 Field field = declaredFields[i]; System.out.println("成员名称为：" + field.getName()); Class fieldType = field.getType(); System.out.println("成员类型为：" + fieldType); boolean isTurn = true; while(isTurn) { try { // 如果该成员变量的访问权限为private，则抛出异常 isTurn = false; System.out.println("修改前成员的值为：" + field.get(book)); // 判断成员类型是否为int if(fieldType.equals(int.class)) { System.out.println("利用setInt()方法修改成员的值"); field.setInt(book, 100); } else if(fieldType.equals(float.class)) { // 判断成员变量类型是否为float System.out.println("利用setFloat()方法修改成员的值"); field.setFloat(book, 29.815f); } else if(fieldType.equals(boolean.class)) { // 判断成员变量是否为boolean System.out.println("利用setBoolean()方法修改成员的值"); field.setBoolean(book, true); } else { System.out.println("利用set()方法修改成员的值"); field.set(book, "Java编程"); } System.out.println("修改后成员的值为：" + field.get(book)); } catch (Exception e) { System.out.println("在设置成员变量值时抛出异常，下面执行setAccessible()方法"); field.setAccessible(true); isTurn = true; } } System.out.println("=============================\n"); } } } -
运行测试类 Test03，程序将会依次动态访问 Book2 类中的所有成员。
2.2.4 java.lang.reflect.Modifier
通过 java.lang.reflect.Modifier 类可以解析出 getMocMers() 方法的返回值所表示的修饰符信息。在该类中提供了一系列用来解析的静态方法，既可以查看是否被指定的修饰符修饰，还可以字符串的形式获得所有修饰符。Modifier 类的常用静态方法如下表所示：
| 方法名称 | 说明 |
|---|---|
| isStatic(int mod) | 如果使用static修饰符修饰则返回true，否则返回false |
| isPublic(int mod) | 如果使用public修饰符修饰则返回true，否则返回false |
| isProtected(int mod) | 如果使用protected修饰符修饰则返回true，否则返回false |
| isPrivate(int mod) | 如果使用private修饰符修饰则返回true，否则返回false |
| isFinal(int mod) | 如果使用final修饰符修饰则返回true，否则返回false |
| toString(int mod) | 以字符串形式返回所有修饰符 |
例如，下列代码判断对象 con 所代表的构造方法是否被 public 修饰，以及以字符串形式获取该构造方法的所有修饰符。
java
// 获取构造方法的修饰符整数
int modifiers = con.getModifiers();
// 判断修饰符整数是否为public
boolean isPublic = Modifier.isPublic(modifiers);
string allModifiers = Modifier.toString(modifiers);三、小结
把今天最好的表现当作明天最新的起点.....．～
总之使用反射机制可以实现很多高级功能，比如动态代理、注解处理等。但是，使用反射机制的时候也需要注意一些问题，比如：性能问题和安全问题。因此，在使用反射机制时需要权衡其优缺点，谨慎使用！
