目录
[1. 定义与用途](#1. 定义与用途)
[2. 反射示例](#2. 反射示例)
[2.1.1 获得Class对象的三种方式](#2.1.1 获得Class对象的三种方式)
[2.1.2 反射的使用](#2.1.2 反射的使用)
[3. 反射（Reflection）在Spring等框架中的核心作用](#3. 反射（Reflection）在Spring等框架中的核心作用)
[3.1 为什么要用反射？](#3.1 为什么要用反射？)
[3.2 反射（Reflection）在Spring框架中的核心步骤](#3.2 反射（Reflection）在Spring框架中的核心步骤)
1. 定义与用途
Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。
上面这段话看着特别懵，甚至不知道在说啥。
反射中比较重要的有四个类。
这四个类所拥有的方法，可以去查阅java官方文档。
这其中最重要的是Class类，理解了Class类，反射就理解了一大半了。
Class类是"类的类"，是Java类型系统在运行时的"总蓝图"和"元数据仓库"。
这样说，还是有一些抽象。接下来做一个比喻。
🗺️ 一个核心比喻：设计图与施工队
想象一家建筑公司，它的电脑里存有所有户型的设计图电子版 （Class对象）。
-
你的源代码 （
.java文件）就像是纸质设计图。 -
编译后 的
.class文件，就是把纸质图纸扫描成了标准的电子文档，存在了公司服务器上。 -
JVM的类加载器 就像是施工队队长 ，他根据项目需要（程序运行），从服务器上找到对应的电子图纸（加载
.class文件），并把它解读成电脑里的一个三维模型 ，这个可操作、可查询的模型就是Class对象。 -
new关键字 则是施工队 ，他们拿着这份Class对象（三维模型），在工地上（堆内存 ）照样子盖出一栋栋真实的房子 （对象实例）。
2. 反射示例
2.1.1 获得Class对象的三种方式
在反射之前，我们需要做的第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，那么，我们就可以修改部分类型信息。
第一种， 使用 Class.forName("类的全路径名"); 静态方法。
前提：已明确类的全路径名。
第二种， 使用 .class 方法。
说明：仅适合在编译前就已经明确要操作的 Class
**第三种，**使用类对象的 getClass() 方法
java
class Student{
//私有属性name
private String name = "dumpling";
//公有属性age
public int age = 18;
//不带参数的构造方法
public Student(){
System.out.println("Student()");
}
private Student(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Student(String,name)");
}
private void eat(){
System.out.println("i am eat");
}
public void sleep(){
System.out.println("i am pig");
}
private void function(String str) {
System.out.println(str);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
java
public class TestDemo {
public static void main(String[] args) {
/*
1.通过getClass获取Class对象
*/
Student s1 = new Student();
Class c1 = s1.getClass();
/*2.直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
这说明任何一个类都有一个隐含的静态成员变量 class*/
Class c2 = Student.class;
/*3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
但可能抛出 ClassNotFoundException 异常 */
Class c3 = null;
try {
c3 = Class.forName("org.example.reflection.Student");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
//一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的
//c1,c2,c3进行 equals 比较，发现都是true
System.out.println(c1.equals(c2));
System.out.println(c1.equals(c3));
System.out.println(c2.equals(c3));
}
}
2.1.2 反射的使用
接下来我们开始使用反射，反射上面的Student类，把反射的逻辑写到另外的类中便于理解。
java
package org.example.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectClassDemo {
//创建对象
public static void reflectNewInstance() {
try {
Class<?> classStudent = Class.forName("org.example.reflection.Student");
Object objectStudent = classStudent.newInstance();
Student student = (Student) objectStudent;
System.out.println("获得学生对象" + student);
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
// 反射私有的构造方法
public static void reflectPrivateConstructor() {
try {
Class<?> classStudent = Class.forName("org.example.reflection.Student");
Constructor<?> declaredConstructorStudent = classStudent.getDeclaredConstructor(String.class, int.class);
//设置为true后可修改访问权限
declaredConstructorStudent.setAccessible(true);
Object objectStudent = declaredConstructorStudent.newInstance("小明", 20);
Student student = (Student) objectStudent;
System.out.println("获得私有构造函数且修改姓名和年龄" + student);
} catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException |
InvocationTargetException e) {
throw new RuntimeException(e);
}
}
// 反射私有属性
public static void reflectPrivateField() {
try {
Class<?> classStudent = Class.forName("org.example.reflection.Student");
Field field;
field = classStudent.getDeclaredField("name");
field.setAccessible(true);
//可以修改该属性的值
Object objectStudent = classStudent.newInstance();
Student student = (Student) objectStudent;
field.set(student,"小明");
String name = (String) field.get(student);
System.out.println("反射私有属性修改了name："+ name);
} catch (Exception ex) {
ex.printStackTrace();
}
}
// 反射私有方法
public static void reflectPrivateMethod() {
try {
Class<?> classStudent = Class.forName("Student");
Method methodStudent = classStudent.getDeclaredMethod("function",String.class);
System.out.println("私有方法的方法名为："+methodStudent.getName());
//私有的一般都要加
methodStudent.setAccessible(true);
Object objectStudent = classStudent.newInstance();
Student student = (Student) objectStudent;
methodStudent.invoke(student,"我是给私有的function函数传的参数");
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
//reflectNewInstance();
//reflectPrivateConstructor();
//reflectPrivateField();
reflectPrivateMethod();
}
}3. 反射（Reflection）在Spring等框架中的核心作用
3.1 为什么要用反射？
因为框架是通用的，它无法预知你的业务类。想象一下，如果没有反射，Spring框架的代码里可能需要写出：
java
// 如果不用反射，框架就需要"硬编码"所有可能的类，这根本不可能！
if ("UserService".equals(beanName)) {
return new UserService();
} else if ("OrderService".equals(beanName)) {
return new OrderService();
}
// ... 无穷无尽反射的价值就在于让框架摆脱了对具体业务类的"硬编码"依赖，实现了"配置化"和"解耦"。
上述的"不可能"不是指技术上的"做不到"，而是指在工程实践、软件设计和维护成本上是"灾难性、不可行"的。
🏪 一个核心类比：餐厅的"死亡菜单"
想象你在开发一个餐厅点菜系统框架。这个框架需要能处理顾客点各种不同的菜。
1. 没有反射的"硬编码"世界：死亡菜单
在这种情况下，你的框架代码必须事先知道世界上所有的菜。代码会是这样的：
java
// 【硬编码的点菜框架核心代码】
public class RestaurantFramework {
public Dish handleOrder(String dishName) {
if ("鱼香肉丝".equals(dishName)) {
return new YuXiangRouSi(); // 直接new一个具体的菜
} else if ("宫保鸡丁".equals(dishName)) {
return new GongBaoJiDing();
} else if ("麻婆豆腐".equals(dishName)) {
return new MaPoDouFu();
} else if ("北京烤鸭".equals(dishName)) {
return new BeijingKaoYa();
}
// ... 如果顾客想点一个"水煮鱼"怎么办？
// 你必须先在这里加上：
// } else if ("水煮鱼".equals(dishName)) {
// return new ShuiZhuYu();
// }
// 然后**重新编译、打包、发布整个框架**！
else {
throw new Error("本店没有这道菜！");
}
}
}这个"死亡菜单"框架的致命问题：
1.无法扩展，如果餐厅想推出一道新菜"水煮鱼"，你必须修改框架的源代码 ，增加一个新的 if 分支和 new ShuiZhuYu()。
2.重新发布，每次加新菜，不是你发布一个新的菜单配置文件，而是必须重新编译、打包、发布整个点菜系统（框架本身） 给所有餐厅。
3.耦合致死，你的框架核心代码牢牢地、直接地依赖了每一个具体的菜品类。框架变得无比臃肿，且与业务细节深度绑定。
那么现在让框架变得更聪明，它不关心具体的菜是什么，只关心一个规则："给我菜名和对应的菜谱（类名），我就能做出来。"
java
// 【使用反射的智能点菜框架核心代码】
public class SmartRestaurantFramework {
// 这个Map就是"菜单配置文件"，可以来自XML、注解或数据库
private Map<String, String> menuConfig = new HashMap<>();
{
// 配置：菜名 -> 对应的菜谱类 (只是一个字符串！)
menuConfig.put("鱼香肉丝", "com.restaurant.dishes.YuXiangRouSi");
menuConfig.put("宫保鸡丁", "com.restaurant.dishes.GongBaoJiDing");
// 新增"水煮鱼"只需在这里加一行配置，完全不用动下面的handleOrder方法！
menuConfig.put("水煮鱼", "com.restaurant.dishes.ShuiZhuYu");
}
public Dish handleOrder(String dishName) {
// 1. 查"菜单"（配置），获取菜谱的类名字符串
String recipeClassName = menuConfig.get(dishName);
if (recipeClassName == null) {
throw new Error("本店没有这道菜！");
}
// 2. 【反射核心】根据类名字符串，动态加载并创建对象
try {
Class<?> dishClass = Class.forName(recipeClassName); // 关键！
return (Dish) dishClass.getDeclaredConstructor().newInstance();
} catch (Exception e) {
throw new Error("这道菜目前做不了。", e);
}
}
}这个"智能菜单"框架的巨大优势：
1.开闭原则，餐厅要增加新菜"水煮鱼"，框架核心代码 handleOrder 一行都不用改 。你只需要在配置文件 （例子中的 menuConfig Map）里增加一个映射关系。
2.解耦，框架只依赖一个抽象的 Dish 接口和字符串形式的类名 。它完全不知道 YuXiangRouSi 或 ShuiZhuYu 的具体实现。这些业务类可以独立开发和发布。
3.通用性，这个框架可以卖给任何餐厅，无论他们有什么奇葩的菜系，框架代码都无需改变，只需提供不同的配置。
🔄 映射回Spring框架
在Spring中，情况完全一样：
| 餐厅系统类比 | Spring 框架对应 |
|---|---|
Dish (菜) |
Object 或 具体的业务接口 (如 UserService) |
YuXiangRouSi (鱼香肉丝) |
你的业务类 (如 UserServiceImpl) |
menuConfig (菜单配置文件) |
Spring的配置 (applicationContext.xml 或 @Configuration 类) |
handleOrder 方法 |
Spring容器的 getBean() 方法 |
Class.forName(...) (反射) |
Spring内部根据配置的类名字符串，动态加载并创建Bean |
没有反射（硬编码），框架代码必须在编译时就明确知道所有它要操作的类。这意味着业务一有变动，框架就要跟着改。框架和业务是"钢筋水泥浇筑在一起"的。
使用反射，框架代码在编译时 只依赖于抽象（接口）和字符串。在运行时，才根据外部的配置信息（字符串），动态地去加载和执行具体的类。框架和业务之间只有"松软的配置文件"连接。
3.2 反射（Reflection）在Spring框架中的核心步骤
🗺️ 第一步：读取配置 - "地图与蓝图"
无论是XML的 <bean class="com.example.UserService"/> 还是注解 @Service，其本质都是向Spring提供了一份"蓝图"或"配料表"。
1.XML配置，像一份写在外部文件中的说明书，明确写了需要创建哪个类（如com.example.UserService）。
2.注解配置，像直接贴在该有零件上的标签（例如在UserServiceImpl类上加@Service），Spring扫描时就能发现它。
🏗️ 第二步：反射创建 - "按图施工"
这是反射最核心的舞台。Spring根据上一步获得的信息（本质上是一个字符串形式的类全限定名），开始动态创建对象。
java
// 这是一个极度简化的Spring内部实现逻辑，帮助理解
public Object createBean(String className) {
// 1. **根据类名找到"模具"**
// 通过反射，将字符串 "com.example.UserService" 转换为可操作的 Class 对象
Class<?> clazz = Class.forName(className);
// 2. **使用"模具"制造"产品"**
// 调用默认构造器，反射实例化一个对象
Object instance = clazz.getDeclaredConstructor().newInstance();
// 3. **依赖注入：为产品装配零件**
// 遍历所有字段，如果字段标记了@Autowired，就寻找对应的Bean并反射注入
for (Field field : clazz.getDeclaredFields()) {
if (field.isAnnotationPresent(Autowired.class)) {
Object dependency = getBeanFromContainer(field.getType()); // 从容器找依赖
field.setAccessible(true); // 反射访问私有字段
field.set(instance, dependency); // 注入！
}
}
return instance;
}🔄 第三步：放入容器与管理 - "仓库与调度"
创建的对象（Bean）会被放入一个称为 "IoC容器" 的大Map里，键是Bean的名字，值是Bean实例。之后所有依赖注入（@Autowired）、AOP切面等，都是对这个容器中的对象进行操作。