万字长文深入理解Java反射机制
本文是我和武哥联合创作，已收录至我们的GitHub，欢迎大家给个Star：https://github.com/nxJava/nx_java
微信搜索：Java学习指南，关注这个专注于分享Java干货的公众号~
文章目录
- 1. 什么是反射？
- 1.1 反射概念
- 1.2 举例说明反射机制
- 1.3 更深入地看下反射机制
- 2. 为什么学反射？
- 2.1 利用反射分工协作
- 2.2 Spring中的反射
- 2.3 Dubbo中的反射
- 2.4 IDEA中的反射
- 2.5 反射在动态代理中的应用
- 2.5.1 JDK动态代理
- 2.5.2 Cglib动态代理
- 2.5.3 Javassist代理
- 3. 怎么学反射？
- 3.1 class对象
- 3.2 成员变量
- 3.3 构造方法
- 3.4 成员方法
- 4. 反射的优缺点
- 4.1 优点
- 4.2 缺点
1. 什么是反射？
1.1 反射概念
我们先看下反射的概念：
Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。
简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的全限定名称(例如 com.example.Student)，那么就可以通过反射机制来获得类的所有信息。
1.2 举例说明反射机制
那么既然有“反”，就应该有“正”，我们没学反射之前是怎么通过正向过程创建对象的呢？
例如我们想创建一个Student的对象，在这之前我们是不是应该创建Student类：
public class Student {
private String name; // 姓名
private Integer age; // 年龄
private String address; // 地址
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
然后我们通过new的方式创建对象，并调用其方法：
Student student = new Student(); // 创建对象
student.setAge(19); // 执行setAge方法
Integer age = student.getAge(); // 获取学生的年龄
System.out.println(age);
好，到此为止我们通过正向的方式创建了一个Student对象，那么通过反射怎么创建Student对象？我们来看下：
Class<?> clazz = Class.forName("Student"); //获取Student类
Object o = clazz.newInstance(); // 通过类创建对象
Method setAgeMethod = clazz.getMethod("setAge", Integer.class); // 获取setAge方法。第一个参数是方法名称，第二个参数是方法的参数类型列表，如果有多个参数可以传多个参数的类型
setAgeMethod.invoke(o, 19); // 执行setAge()方法
Method getAgeMethod = clazz.getMethod("getAge"); // 获取getAge方法
Object age = getAgeMethod.invoke(o); // 执行getAge方法
System.out.println(age);
以上两种方法都可以打印年龄19：
这就是反射，在程序运行的时候动态创建类的实例，并通过实例调用类的方法。
1.3 更深入地看下反射机制
java源文件从创建到运行会经历3个阶段，分别是源码阶段、Class类对象阶段和运行阶段。在java文件编译成class文件后，通过类加载器将class的信息加载进内存，在内存中class字节码文件被描述成3种对象信息，分别是成员变量对象、构造方法对象、成员方法对象，它们都是多个，所以是数组。这个Class对象阶段就是反射机制，我们通过Class可以得到类的所有信息，创建对象和调用其成员方法。
2. 为什么学反射？
2.1 利用反射分工协作
从上面的例子我们可以看出，如果你事先创建好了Student类，那么你可以直接创建Student对象并调用其方法，那么如果我和另外一位老铁分开开发程序，这个Student类是他写的，我们彼此开发完全独立，我需要在我的程序中创建Studnet对象，然后调用Student方法获取学生的年龄，这个时候可能这位老铁还没有完成Student类的开发，这怎么办？
这就用到了反射了，我在开发程序的时候只需要跟他约定好Studnet类的信息，例如类名称，字段名称、方法名称，我就可以通过反射的机制在他还未写Studnet类的时候动态创建Studnet对象并调用其方法了。等他的Studnet类完成创建之后，我们的代码合并部署运行，我就可以调用到Student的方法了。
2.2 Spring中的反射
其实在框架内部处处都是反射的应用，反射是框架的灵魂。比如我们最常用的Spring框架，在定义一个bean的时候我们可能会这么做：
<bean id="studentBean" class="com.example.Student"/>
在xml文件中定义一个bean，告诉Spring我需要一个Student对象，这个对象的名称是com.example.Student，那么Spring就会通过我们上面那种方式去生成对象：
Class clazz = Class.forName("com.example.Student"); // 通过名称得到Class
Object stuObj = clazz.newInstance(); // 生成对象
生成完对象之后，Spring会把这个对象放在一个容器中，在实际需要的时候通过@Autoware或者@Resource等注解的方式去获取对象，或者通过ApplicationContext获取bean对象。
2.3 Dubbo中的反射
我们常用的RPC框架，例如DUBBO，在接口调用的时候，也是应用反射机制。
RPC框架根据客户端的请求 ：接口名称（interface）、方法名称（method）、参数类型（paramtype）、参数（params）等进行反射，dubbo接口之间通信的机制大概是这样的：
通过反射我们可以实现上面的流程：
String className = request.getClassName(); // 获取类名称
Class<?> c = Class.forName(className); // 得到Class信息
Object serviceBean = c.newInstance(); // 创建对象
String methodName = request.getMethodName(); // 得到调用的接口名称
Class<?> paramTypes = request.getParamTypes(); // 获取接口的参数类型
Object[] params = request.getParams(); // 得到消费方调用接口的参数
Method method = c.getMethod(methodName, paramTypes); // 得到接口
method.invoke(serviceBean , params); // 执行接口调用
2.4 IDEA中的反射
再比如我们在写代码的时候，创建一个字符串对象，调用其方法，我们是不是通过 ".“来获取方法的？
你看通过”."我们可以看到String对象的所有方法信息，这是怎么做到的？其实这也是利用了Java的反射机制。
idea在运行期间，通过反射获取到了String对象的全部方法，然后列举成一个列表，描述了方法的名称、参数和返回值，我们在使用的时候可以直接选择想要的方法，非常方便。
2.5 反射在动态代理中的应用
2.5.1 JDK动态代理
Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
- Interface InvocationHandler：该接口中仅定义了一个方法Object，invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
- Proxy：该类即为动态代理类。
2.5.2 Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。JDK代理要求被代理的类必须实现接口，有很强的局限性。而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。在CGLIB底层，其实是借助了ASM这个非常强大的Java字节码生成框架。
2.5.3 Javassist代理
一种是使用代理工厂创建，另一种通过使用动态代码创建。使用代理工厂创建时，方法与CGLIB类似，也需要实现一个用于代理逻辑处理的Handler；使用动态代码创建，生成字节码，这种方式可以非常灵活，甚至可以在运行时生成业务逻辑。
3. 怎么学反射？
最简单粗暴的方法就是对着API撸！
3.1 class对象
获取class对象的三种方式
Class.forName("全类名")，将字节码文件加载进内存，获取class对象；- 类名.class，通过类的class属性获取；
- 对象.getClass()，getClass方法在Object类中定义的，所以对象都有这个方法。
Class clazz = Class.forName("Student"); // 可能会抛出ClassNotFoundException异常
Class clazz1 = Student.class;
Class<?> clazz2 = new Student().getClass();
注意，同一个字节码.class文件只会被加载一次，无论哪种方式获取的Class对象都是同一个。
3.2 成员变量
- getFields()， 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
- getField(String name)，返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
- getDeclaredFields()，返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
- getDeclaredField(String name)， 返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
我们来具体演示下。
为了达到演示效果，Studnet类稍作修改，有四个属性，分别使用public、protected、default、private来修饰。
public class Student {
public String name;
protected Integer age;
String address;
private String phone;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
}
先看下getFields和getField方法
Class clazz = Student.class;
Field[] fields = clazz.getFields();
for (Field field : fields) {
System.out.println("getFields======" + field);
}
Field field = clazz.getField("name");
System.out.println("getField name======" + field);
Field field1 = clazz.getField("age");
System.out.println("getField age======" + field1);
运行结果：
我们可以看到，getFields只获得了Student的name属性，由于age属性是protected修饰的，所以getField(“age”)抛出了NoSuchFieldException的异常。
那么怎么获得非public修饰的属性？我们可以通过getDeclaredFields和getDeclaredField(‘name’)两个方法来获取：
Field[] declaredFields = clazz.getDeclaredFields(); // 获取所有已声明的属性
for (Field declaredField : declaredFields) {
System.out.println("getDeclaredFields======" + declaredField);
}
Field ageField = clazz.getDeclaredField("age"); // 获取指定名称的已声明的属性
System.out.println("getDeclaredField age=========" + ageField);
运行结果
可以看到我们拿到了类的所有已声明字段，那么拿到了这些字段我们就可以获取对象对应字段的值了，来试下：
Student student = new Student(); // new一个Student对象
student.setName("小明"); // 设置属性值
student.setAge(20);
student.setAddress("上海市");
student.setPhone("13011220099");
Field[] declaredFields = clazz.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("field=" + declaredField.getName() + ",value=" + declaredField.get(student)); // 获取属性值
}
那么结果会是什么样子的？
可以看到，前3个属性的值打印出来了，也就是说非private修饰的属性可以通过declaredField.get(obj)的方式从对象中获取其属性值，但是private修饰的属性phone在获取属性值的时候会抛出java.lang.IllegalAccessException异常，无法访问。
那么private修饰的属性我们如何从对象中获取其属性值？我们需要加上这一句：
// 忽略访问权限修饰符的安全检查
declaredField.setAccessible(true);
忽略了访问权限修饰符的权限限制，我们就可以通过反射获取任意属性的属性值了。
注意：getDeclared***同样适用于Constructor和Method，分别是getDeclaredConstructor()和getDeclaredMethod()，通过setAccessible(true)这种方式可以忽略其访问限制，从而可以使用类私有的属性、构造器和方法。
3.3 构造方法
- getConstructor(Class… parameterTypes)，返回一个 Constructor对象Constructor，该对象反映 Constructor对象表示的类的指定的公共 类函数。
- getConstructors()，返回包含一个数组 Constructor对象Constructor[]，反射由此表示的类的所有公共构造类对象。
- getDeclaredConstructor(类… parameterTypes)，返回一个 Constructor对象Constructor，该对象反映 Constructor对象表示的类或接口的指定 类函数。
- getDeclaredConstructors()，返回一个反映 Constructor对象表示的类声明的所有 Constructor对象的数组类Constructor[]。
获取构造器的作用是为了new对象，可以通过有参、无参的构造器创建对象，无参构造器创建的对象等同于Class提供的newInstance方式创建对象：
Constructor constructor = clazz.getConstructor(String.class, Integer.class); // Constructor 有参构造
Object stu = constructor.newInstance("张三", 12); // 创建对象
System.out.println("Constructor有参构造对象======" + stu);
Constructor constructor1 = clazz.getConstructor(); // Constructor 无参构造
Object stu1 = constructor1.newInstance(); // 创建对象
System.out.println("Constructor无参构造======" + stu1);
Object stu2 = clazz.newInstance(); // Constructor无参构造创建对象简写形式：Class创建对象
System.out.println("Class无参构造======" + stu2);
运行结果：
3.4 成员方法
- getMethod(String name, Class… parameterTypes)，获取一个指定名称和参数类型的public修饰的方法对象。
- getMethods()，获取所有的public修饰的方法列表。
- getDeclaredMethod(String name, Class… parameterTypes)，获取已声明的指定名称和参数类型的的成员方法。
- getDeclaredMethods())，获取已声明的所有成员方法。
我们还是用Student类来演示，先给Student加上两个成员方法：
public void eat() {
System.out.println("eat");
}
public void eat(String food) {
System.out.println("eat " + food);
}
现在来利用反射调用下这两个方法：
Student student = new Student(); // 创建Student对象
Method eatMethod = clazz.getMethod("eat"); // 获取eat方法对象
eatMethod.invoke(student); // 执行eat方法
Method eatMethod1 = clazz.getMethod("eat", String.class); // 获取有参eat方法对象
eatMethod1.invoke(student, "香蕉"); // 执行有参eat方法
运行结果：
那么getMethods是不是获取Studnet定义的成员方法呢？
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.println(method);
}
运行结果：
可以看到Object类定义的成员方法也被打印出来了，所以这里我们要注意getMethods()方法会获取类自身以及Object类中定义的所有成员方法。
4. 反射的优缺点
4.1 优点
反射提高了程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提前硬编码目标类；
4.2 缺点
- 性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用。
- 使用反射会模糊程序内内部逻辑：程序员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。
创作不易，如果您喜欢这篇文章的话，请你 点赞 + 评论 支持一下作者好吗？您的支持是我创作的源泉哦！喜欢Java，热衷学习的小伙伴可以加我微信: xia_qing2012 ，私聊我可以获取最新Java基础到进阶的全套学习资料。大家一起学习进步，成为大佬！