面试官：反射都不会，还敢说自己会 Java？

（文末有惊喜）

一、反射机制

1.1 框架

在学习 Java 的路上，相信你一定使用过各种各样的框架。所谓的框架就是一个半成品软件，已经对基础的代码进行了封装并提供相应的 API。在框架的基础上进行软件开发，可以简化编码。学习使用框架并不需要了解反射，但是如果想要自己写一个框架，那么就需要对反射机制有很深入的了解。

1.2 什么是反射机制？

在程序运行状态中，对于任意一个类或对象，都能够获取到这个类的所有属性和方法（包括私有属性和方法），这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来讲，通过反射，类对我们是完全透明的，想要获取任何东西都可以。

1.3 反射的优点

可以在程序运行过程中，操作这些对象；

可以解耦，提高程序的可扩展性。

在学习反射以前，我们先来了解一下 Java 代码在计算机中所经历的三个阶段：

Source 源代码阶段：.java 被编译成*.class 字节码文件。

Class 类对象阶段：.class 字节码文件被类加载器加载进内存，并将其封装成 Class 对象（用于在内存中描述字节码文件），Class 对象将原字节码文件中的成员变量抽取出来封装成数组 Field[],将原字节码文件中的构造函数抽取出来封装成数组 Construction[]，将成员方法封装成数组 Method[]。当然 Class 类内不止这三个，还封装了很多，我们常用的就这三个。

RunTime 运行时阶段：使用 new 创建对象的过程。

二、获取 Class 对象

2.1 获取 Class 对象的三种方式

【Source 源代码阶段】 Class.forName(“全类名”)：将字节码文件加载进内存，返回 Class 对象；

多用于配置文件，将类名定义在配置文件中，通过读取配置文件加载类。

【Class 类对象阶段】 类名.class：通过类名的属性 class 获取；

多用于参数的传递

【Runtime 运行时阶段】对象.getClass()：此方法是定义在 Objec 类中的方法，因此所有的类都会继承此方法。

多用于对象获取字节码的方式

2.2 方法演示

public class getClass {

public static void main(String[] args) throws Exception {

//方式一：Class.forName("全类名");

Class class1 = Class.forName("zzuli.edu.cn.Person"); //Person 自定义实体类

System.out.println("class1 = " + class1);

//方式二：类名.class

Class class2 = Person.class;

System.out.println("class2 = " + class2);

//方式三：对象.getClass();

Person person = new Person();

Class class3 = person.getClass();

System.out.println("class3 = " + class3);

//比较三个对象

System.out.println(class1 == class2); //true

System.out.println(class1 == class3); //true

}

}

运行结果：

通过上述比较三个对象的结果可以得出一个结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的 Class 对象都是同一个。（文末有惊喜）

三、 Class 对象的功能

3.1 获取功能

这里只写出一些常用的，具体可以参看 jdk 的帮助文档。

获取成员变量

Field[] getFields() //获取所有 public 修饰的成员变量

Field getField(String name) //获取指定名称的 public 修饰的成员变量

Field[] getDeclaredFields() //获取所有的成员变量，不考虑修饰符

Field getDeclaredField(String name) //获取指定的成员变量，不考虑修饰符

获取构造方法

Constructor<?>[] getConstructors() //获取所有 public 修饰的构造函数

Constructor<T> getConstructor(类<?>... parameterTypes) //获取指定的 public 修饰的构造函数

Constructor<?>[] getDeclaredConstructors() //获取所有的构造函数，不考虑修饰符

Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) //获取指定的构造函数，不考虑修饰符

3. 获取成员方法

Method[] getMethods() //获取所有 public 修饰的成员方法

Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的 public 修饰的成员方法

Method[] getDeclaredMethods() //获取所有的成员方法，不考虑修饰符

Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法，不考虑修饰符

获取全类名

String getName()

3.2 Field：成员变量

（1）设置值 void set(Object obj, Object value)

（2）获取值 get(Object obj)

（3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

3.2.1 测试的实体类

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Setter

@Getter

@ToString

public class Person {

public String a; //最大范围 public

protected String b; //受保护类型

String c; //默认的访问权限

private String d; //私有类型

}

3.2.2 测试 getFields 和 getField(String name)方法

/**

* 获取成员变量

* * Field[] getFields()

* * Field getField(String name)

* @throws Exception

*/

public class reflectDemo1{

public static void main(String[] args) throws Exception {

//获取 Person 的 Class 对象

Class personClass = Person.class;

//1、Field[] getFields()获取所有 public 修饰的成员变量

Field[] fields = personClass.getFields();

for(Field field : fields){

System.out.println(field);

}

System.out.println("=============================");

//2.Field getField(String name) 获取指定名称的 public 修饰的成员变量

Field a = personClass.getField("a");

//获取成员变量 a 的值 [也只能获取公有的，获取私有的或者不存在的字符会抛出异常]

Person p = new Person();

Object value = a.get(p);

System.out.println("value = " + value);//因为在 Person 类中 a 没有赋值，所以为 null

//设置成员变量 a 的属性值

a.set(p,"张三");

System.out.println(p);

}

}

运行结果：

3.2.3 测试 getDeclaredFields 和 getDeclaredField(String name)方法

/**

* Field[] getDeclaredFields()

* Field getDeclaredField(String name)

* @throws Exception

*/

public class reflectDemo2 {

public static void main(String[] args) throws Exception {

//获取 Person 的 Class 对象

Class personClass = Person.class;

//Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符

Field[] declaredFields = personClass.getDeclaredFields();

for(Field filed : declaredFields){

System.out.println(filed);

}

System.out.println("===================================");

//Field getDeclaredField(String name) //获取指定的成员变量，不考虑修饰符

Field d = personClass.getDeclaredField("d"); //private String d;

Person p = new Person();

//Object value1 = d.get(p); //如果直接获取会抛出异常，因为对于私有变量虽然能会获取到，但不能直接 set 和 get，必须忽略访问权限修饰符的安全检查后才可以

//System.out.println("value1 = " + value1);

//忽略访问权限修饰符的安全检查，又称为暴力反射

d.setAccessible(true);

Object value2 = d.get(p);

System.out.println("value2 = " + value2);

}

}

运行结果

注意：如果没有忽略访问修饰符直接访问会抛出如下所示的异常

3.3 Constructor:构造方法

创建对象：T newInstance(Object… initargs)注意：如果使用空参数构造方法创建对象，操作可以简化：直接使用 Class 对象的 newInstance 方法。

3.3.1 修改测试的实体类

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Setter

@Getter

@ToString

public class Person {

private String name;

private Integer age;

//无参构造函数

public Person() {

}

//单个参数的构造函数，且为私有构造方法

private Person(String name){

}

//有参构造函数

public Person(String name, Integer age) {

this.name = name;

this.age = age;

}

}

3.3.2 测试获取构造函数的方法

/**

* 获取构造方法

* Constructor<?>[] getConstructors()

* Constructor<T> getConstructor(类<?>... parameterTypes)

*/

public class reflectDemo3 {

public static void main(String[] args) throws Exception {

//获取 Person 的 Class 对象

Class personClass = Person.class;

//Constructor<?>[] getConstructors() //获取所有 public 修饰的构造函数

Constructor[] constructors = personClass.getConstructors();

for(Constructor constructor : constructors){

System.out.println(constructor);

}

System.out.println("==========================================");

//获取无参构造函数 注意：Person 类中必须要有无参的构造函数，不然抛出异常

Constructor constructor1 = personClass.getConstructor();

System.out.println("constructor1 = " + constructor1);

//使用获取到的无参构造函数创建对象

Object person1 = constructor1.newInstance();

System.out.println("person1 = " + person1);

System.out.println("==========================================");

//获取有参的构造函数 //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致，且参数类型为字节码文件类型

Constructor constructor2 = personClass.getConstructor(String.class,Integer.class);

System.out.println("constructor2 = " + constructor2);

//使用获取到的有参构造函数创建对象

Object person2 = constructor2.newInstance("zhangsan", 22); //获取的是有参的构造方法，就必须要指定参数

System.out.println(person2);

System.out.println("=========================================");

//对于一般的无参构造函数，我们都不会先获取无参构造器之后在进行初始化,而是直接调用 Class 类内的 newInstance()方法

Object person3 = personClass.newInstance();

System.out.println("person3 = " + person3);

}

}

运行结果：

java 学习交流群：925895158，欢迎各小白和大佬进群交流

总结：如果使用无参构造方法创建对象，操作可以进行简化：直接使用 Class 对象的 newInstance 方法创建即可。

对于多出个 Declared 关键词的两个方法，与不带这个词的两个方法的对比，与之前 3.2 叙述的一样，getDeclaredConstructor 方法可以获取到任何访问权限的构造器，而 getConstructor 方法只能获取 public 修饰的构造器，具体不再测试。此外在构造器的对象内也有 setAccessible(true)方法，把它设置成 true 就可以操作了。

3.4 Method：方法对象

执行方法：Object invoke(Object obj, Object… args)

3.4.1 修改测试的实体类

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Setter

@Getter

@ToString

public class Person {

private String name;

private Integer age;

//无参构造函数

public Person() {

}

//有参构造函数

public Person(String name, Integer age) {

this.name = name;

this.age = age;

}

//无参方法

public void eat(){

System.out.println("eat...");

}

//重载有参方法

public void eat(String food){

System.out.println("eat..."+food);

}

}

3.4.2 测试获取成员方法的方法

/**

* 获取成员方法

* * Method[] getMethods()

* * Method getMethod(String name, 类<?>... parameterTypes)

*/

public class reflectDemo4 {

public static void main(String[] args) throws Exception {

//获取 Person 的 Class 对象

Class personClass = Person.class;

//获取指定名称的方法

Method eat_method1 = personClass.getMethod("eat");

//执行方法

Person person = new Person();

Object rtValue = eat_method1.invoke(person);//如果方法有返回值类型可以获取到，没有就为 null

//因为 eat 方法没有返回值，故输出 null

System.out.println("rtValue = " + rtValue);

System.out.println("--------------------------------------------");

//获取有参的函数，有两个参数：第一个参数为方法名，第二个参数是获取方法的参数类型的字节码文件

Method eat_method2 = personClass.getMethod("eat", String.class);

//执行方法

eat_method2.invoke(person,"苹果");

System.out.println("============================================");

//获取方法列表

Method[] methods = personClass.getMethods();

for(Method method : methods){ //注意：获取到的方法不仅仅是 Person 类内自己的方法

System.out.println(method); //继承 Object 中的方法也会被获取到（当然前提是 public 修饰的）

}

}

}

运行结果

我们可以看出 Person 内的 public 方法都被打印出来了，此外 Object 中的 public 方法也都被打印出来了。

同之前的叙述一样，带有 Declared 关键字的方法这两个方法，可以获取到任意修饰符的方法。同样也提供了 setAccessible(true)方法进行暴力反射。

综上所述：在反射面前没有公有私有，都可以通过暴力反射解决。

3.5 获取全类名

getName()方法获取的类名是全类名（带有路径）

public class getNameDemo {

public static void main(String[] args) throws Exception {

//获取 Person 的 Class 对象

Class personClass = Person.class;

//获取全类名

String className = personClass.getName();

System.out.println(className);

}

}

运行结果

四、反射机制的应用案例

4.1 案例分析

4.1.1 需求

写一个"框架"，在不改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中的任意方法。

4.1.2 实现

（1）配置文件

（2）反射机制

4.1.3 步骤

（1）将需要创建的对象的全类名和需要执行的方法定义在配置文件中

（2）在程序中加载读取配置文件

（3）使用反射技术把类文件加载进内存

（4）创建对象

（5）执行方法

4.2 代码实现

4.2.1 需要的实体类

(1)Person 类

public class Person {

//无参方法

public void eat(){

System.out.println("eat...");

}

}

(2)Student 类

public class Student {

//无参方法

public void study(){

System.out.println("I am a Student");

}

}

4.2.2 编写配置文件

className = zzuli.edu.cn.Person

methodName = eat

4.2.3 实现框架

/**

* 前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法

* 即：拒绝硬编码

*/

public class ReflectTest {

public static void main(String[] args) throws Exception {

//1.加载配置文件

//1.1 创建 Properties 对象

Properties pro = new Properties();

//1.2 加载配置文件

//1.2.1 获取 class 目录下的配置文件(使用类加载器)

ClassLoader classLoader = ReflectTest.class.getClassLoader();

InputStream inputStream = classLoader.getResourceAsStream("pro.properties");

pro.load(inputStream);

//2.获取配置文件中定义的数据

String className = pro.getProperty("className");

String methodName = pro.getProperty("methodName");

//3.加载该类进内存

Class cls = Class.forName(className);

//4.创建对象

Object obj = cls.newInstance();

//5.获取方法对象

Method method = cls.getMethod(methodName);

//6.执行方法

method.invoke(obj);

}

}

4.2.4 运行结果

4.2.5 修改配置文件，再次运行

//将配置文件内的信息修改为 Student 类及类内的 study 方法

className = zzuli.edu.cn.Student

methodName = study

运行结果

优点：对于框架来说，已经对基础的代码进行了封装并提供相应的 API。在框架的基础上进行软件开发，可以简化编码。但如果我们使用传统的 new 形式来实例化，那么当类更改时我们就要修改 Java 代码，这是很繁琐的。修改 Java 代码以后我们还要进行重新编译、测试、发布等一系列的操作。而如果我们仅仅只是修改配置文件，而不需要修改 Java 代码就简单的多。

此外使用反射还能达到解耦的效果，如果我们使用的是 new 这种形式进行对象的实例化。此时如果在项目的某一个小模块中我们的一个实例类丢失了，那么在编译期间就会报错，会导致整个项目无法启动。而对于反射创建对象 Class.forName(“全类名”)这种形式，我们在编译期需要的仅仅只是一个字符串（全类名），在编译期不会报错，这样其他的模块就可以正常的运行，而不会因为一个模块的问题导致整个项目崩溃。

如果你认真看完了这篇文章，反射就应该掌握的差不多了，在接下来的几篇文章中，我会使用反射来实现热加载、反编译，并且使用反射来简单封装一个 Spring 框架和 MyBatis 框架。如果想要对反射机制有更深入的了解，可以看后续的文章。

小编最近整理出了最新的 java 零基础资料和进阶文档，快来扫一扫免费领取吧，名额有限哦