前言
在 Java 的核心特性中，反射（Reflection）是一个既基础又高阶的知识点。说它基础，是因为几乎所有主流框架（Spring、MyBatis、SpringBoot）的底层实现都离不开反射；说它高阶，是因为很多开发者只会简单调用反射 API，却对其底层原理、应用场景和性能问题一知半解。
很多人觉得反射 “玄乎”，本质是没有理解 “动态” 的核心 —— 普通的 Java 代码是编译期就确定了类、方法、属性，而反射让程序可以在运行时动态获取类的完整结构，并且调用任意对象的方法、修改任意属性。
本文将从基础概念出发，结合代码示例拆解反射的核心 API，深入底层原理，再结合实战场景讲透反射的应用与优缺点，帮你彻底掌握 Java 反射机制。
一、什么是反射机制？

1. 正向调用 vs 反射调用
   在理解反射之前，先看我们最熟悉的 “正向编程”：
   编译期就知道要使用的类，比如User user = new User();
   直接通过对象调用 public 方法、访问 public 属性
   代码逻辑在编译时就已经固定，运行期无法修改
   而反射是反向的：
   运行期才知道要操作的类是什么，比如从配置文件、网络传输中拿到全类名
   运行时动态加载类，获取类的完整结构（构造方法、属性、方法、注解等）
   动态调用对象的方法、修改属性，甚至可以访问私有成员
   简单来说：反射就是 Java 提供的一套 API，让我们可以在运行时操作类的元数据。

2. 反射的基石：Class 对象
   Java 反射的一切操作，都基于java.lang.Class这个类。
   Java 是纯面向对象语言，一切皆对象：普通的对象是类的实例，而类本身也是对象—— 每个类在被加载后，JVM 都会在方法区（JDK8 后为元空间）生成一个对应的Class对象，这个对象保存了类的全部元数据信息（类名、父类、接口、构造器、字段、方法等）。
   反射的本质，就是拿到这个 Class 对象，然后通过它反向获取、操作类的所有信息。
   二、获取 Class 对象的 4 种方式
   操作反射的第一步，就是获取目标类的 Class 对象，常见有 4 种方式，各有适用场景。
   方式 1：类名.class
   直接通过类名.class获取，编译期就能确定 Class 对象，最安全、性能最高。
   Class clazz = User.class;
   特点：不需要实例化对象，编译期加载，不会触发类的初始化。
   方式 2：对象.getClass ()
   如果已经有了类的实例对象，调用对象从 Object 类继承的getClass()方法获取。
   User user = new User();
   Class<? extends User> clazz = user.getClass(); 特点：必须已有实例对象，适合已经拿到对象、但不知道具体类型的场景。 方式 3：Class.forName ("全类名") 通过类的全限定名（包名 + 类名）动态加载，框架开发中最常用。 // 抛出ClassNotFoundException Class<?> clazz = Class.forName(“com.example.entity.User”);
   特点：运行期动态加载，会触发类的初始化；最灵活，只需要字符串就能加载类，是 Spring IOC、JDBC 加载驱动的核心实现。
   方式 4：类加载器.loadClass ()
   通过 ClassLoader 的loadClass()方法加载。
   Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass(“com.example.entity.User”);
   特点：只加载类，不会触发类的初始化（连接、初始化阶段都不会执行），在一些需要延迟初始化的场景中使用。
   常见面试题：Class.forName () 和 ClassLoader.loadClass () 区别？
   Class.forName ()：默认会完成类的初始化（执行静态代码块、静态变量赋值）
   ClassLoader.loadClass ()：只完成加载阶段，不会触发连接和初始化，更轻量化
   三、反射核心操作：构造器、字段、方法全解析
   拿到 Class 对象后，就可以操作类的所有结构了。Java 反射的核心操作分为三类：操作构造方法、操作成员变量、操作成员方法。

3. 操作构造方法（Constructor）
   反射通过Constructor类封装构造方法的信息，可以动态创建对象。
   常用 API
   方法 作用
   getConstructors() 获取当前类所有 public 构造方法
   getDeclaredConstructors() 获取当前类所有构造方法，包括私有
   getConstructor(Class<?>... parameterTypes) 获取指定参数的 public 构造方法 getDeclaredConstructor(Class<?>… parameterTypes) 获取指定参数的任意构造方法，包括私有
   newInstance(Object… initargs) 通过构造器创建对象实例
   代码示例
   public class User {
   private String name;
   private int age;

   // 私有构造方法
   private User(String name) {
   this.name = name;
   }

   // 公有无参构造
   public User() {}

   // 公有全参构造
   public User(String name, int age) {
   this.name = name;
   this.age = age;
   }
   }
   public class ReflectTest {
   public static void main(String[] args) throws Exception {
   Class<?> clazz = Class.forName(“com.example.entity.User”);

    // 1. 获取公有全参构造并创建对象
    Constructor<?> publicConstructor = clazz.getConstructor(String.class, int.class);
    User user1 = (User) publicConstructor.newInstance("张三", 20);
   
    // 2. 获取私有构造方法并创建对象（暴力反射）
    Constructor<?> privateConstructor = clazz.getDeclaredConstructor(String.class);
    // 取消Java访问权限检查，突破private限制
    privateConstructor.setAccessible(true);
    User user2 = (User) privateConstructor.newInstance("李四");
   

   }
   }
   注意：JDK9 之后，Class.newInstance() 已经被废弃，推荐通过 Constructor 的newInstance()创建对象，更安全可控。

4. 操作成员变量（Field）
   通过Field类可以获取、修改对象的成员变量，甚至是 private 修饰的私有属性。
   常用 API
   方法 作用
   getFields() 获取当前类及父类所有 public 字段
   getDeclaredFields() 获取当前类所有字段，包括私有，不含父类
   getField(String name) 根据名称获取指定 public 字段
   getDeclaredField(String name) 根据名称获取当前类任意字段
   get(Object obj) 获取指定对象的该字段值
   set(Object obj, Object value) 修改指定对象的该字段值
   代码示例
   public static void main(String[] args) throws Exception {
   Class<?> clazz = User.class;
   User user = (User) clazz.getConstructor().newInstance();

   // 获取私有字段name
   Field nameField = clazz.getDeclaredField(“name”);
   // 取消权限检查
   nameField.setAccessible(true);

   // 给对象的name字段赋值
   nameField.set(user, “王五”);
   // 获取对象的name字段值
   String name = (String) nameField.get(user);
   System.out.println(name); // 王五
   }

5. 操作成员方法（Method）
   通过Method类可以动态调用对象的方法，包括私有方法。
   常用 API
   方法 作用
   getMethods() 获取当前类及父类所有 public 方法
   getDeclaredMethods() 获取当前类所有方法，包括私有，不含父类
   getMethod(String name, Class<?>... parameterTypes) 获取指定名称和参数的 public 方法 getDeclaredMethod(String name, Class<?>… parameterTypes) 获取当前类指定的任意方法
   invoke(Object obj, Object… args) 调用指定对象的该方法，传入参数
   代码示例
   public class User {
   // 公有方法
   public void sayHello(String msg) {
   System.out.println(“你好：” + msg);
   }

   // 私有方法
   private String getPrivateInfo(String secret) {
   return “秘密：” + secret;
   }
   }

public static void main(String[] args) throws Exception {
Class<?> clazz = User.class;
User user = (User) clazz.getConstructor().newInstance();

// 调用公有方法
Method sayHello = clazz.getMethod("sayHello", String.class);
sayHello.invoke(user, "Java反射"); // 输出：你好：Java反射

// 调用私有方法
Method getPrivateInfo = clazz.getDeclaredMethod("getPrivateInfo", String.class);
getPrivateInfo.setAccessible(true);
String result = (String) getPrivateInfo.invoke(user, "底层原理");
System.out.println(result); // 输出：秘密：底层原理

}
细节补充：如果调用的是静态方法，invoke()的第一个参数（对象实例）传null即可，因为静态方法不属于某个对象。
四、反射的底层原理与性能问题

1. 反射的底层执行流程
   类加载阶段：JVM 通过类加载器把.class 文件加载到内存，在方法区生成对应的 Class 对象，保存类的全部元数据。
   获取 Class 对象：我们通过上述 4 种方式拿到这个 Class 对象。
   查找元数据：调用getMethod()/getField()时，JVM 会去方法区的 Class 对象中查找对应的方法、字段元数据。
   权限校验：默认会执行访问权限检查，如果是 private 成员，不设置setAccessible(true)会抛出异常。
   动态调用：invoke()方法会在运行时动态解析方法入口，完成参数压栈、方法执行、结果返回。
2. 反射为什么慢？
   很多人都知道 “反射性能差”，但差在哪里？核心原因有 3 点：
   权限检查开销：每次反射调用都会默认做访问权限校验，消耗时间。
   方法查找开销：需要遍历 Class 对象的元数据，查找对应的方法 / 字段，不像正向调用编译期就确定了方法地址。
   无法编译优化：正向调用的代码 JIT 编译器可以做内联、逃逸分析等优化；反射调用是动态的，JIT 很难优化，执行效率低。
   装箱拆箱开销：invoke()的参数是 Object 数组，基本类型会自动装箱，产生额外对象开销。
   优化小技巧：
   调用setAccessible(true)，取消权限检查，能提升 30% 左右的性能；
   把 Class、Method、Field 对象缓存起来，避免重复查找；
   非必要场景不滥用反射，优先用正向调用。
   五、反射的经典应用场景
   反射看似 “离日常开发远”，实则我们每天都在间接使用。主流框架的核心能力，几乎都依赖反射实现。
3. Spring IOC 依赖注入
   Spring 的控制反转是最经典的反射应用。配置文件或注解中只写了类的全限定名，Spring 容器启动时，通过Class.forName()动态加载类，通过反射调用构造方法创建 Bean 对象，再通过反射给属性赋值（依赖注入），实现了对象创建和业务代码的解耦。
4. MyBatis ORM 结果映射
   MyBatis 执行 SQL 查询后，返回的是 ResultSet 结果集。它不知道我们要映射成哪个 Java 对象，就是通过反射拿到实体类的 Class 对象，动态调用 setter 方法，把数据库字段的值设置到 Java 对象的对应属性中，完成 ORM 映射。
5. JDK 动态代理
   Java 的动态代理Proxy.newProxyInstance()底层完全基于反射：生成代理类后，通过InvocationHandler的invoke()方法，在运行时动态调用目标对象的方法，实现功能增强，也是 Spring AOP 的核心基础之一。
6. 注解解析
   Java 的自定义注解本身只是标记，没有任何功能，所有注解的逻辑都是靠反射实现的。比如@RequestMapping、@Autowired，框架启动时通过反射扫描类、方法、字段上的注解，根据注解信息执行对应的逻辑。
7. 通用工具类
   很多通用工具类都基于反射实现，比如 Apache 的BeanUtils、Spring 的BeanWrapper，可以实现两个对象之间的属性拷贝；还有 JSON 序列化框架（Jackson、Fastjson），也是通过反射遍历对象的所有字段，完成序列化和反序列化。
   六、反射的优缺点与使用规范
   优点
   极致的灵活性：运行时动态加载、动态调用，实现代码解耦，大幅提升程序的扩展性。
   通用编程能力：可以写出通用的工具、框架，不用针对每个类写重复逻辑。
   突破封装限制：特殊场景下可以访问私有成员，方便测试、特殊业务处理。
   缺点
   性能损耗：相比正向调用有明显的性能差距，高频调用场景需要谨慎使用。
   破坏封装性：可以访问私有成员，违背了 Java 面向对象的封装设计原则，增加了代码的不可控性。
   类型安全风险：反射是运行期才检查类型，编译期无法发现类型错误，容易出现ClassCastException、方法不存在等运行时异常。
   维护成本高：反射代码相对晦涩，排查问题难度更高，对开发人员的技术要求更高。
   使用规范
   能用正向调用实现的逻辑，不要滥用反射；
   反射操作的 Method、Field 对象尽量缓存，减少重复查找开销；
   访问非 public 成员时，统一设置setAccessible(true)提升性能；
   做好异常捕获和空值处理，避免运行时崩溃；
   框架层、工具层适合用反射，业务层尽量少用直接反射。
   总结
   反射是 Java 动态性的核心体现，也是从 “业务开发” 到 “理解框架” 的必经之路。它不是什么高深的黑科技，本质就是 JVM 暴露出来的一套操作类元数据的 API。
   学习反射，不只是为了记住几个 API，更重要的是理解 “运行时动态操作” 的思想 —— 当你看懂了 Spring、MyBatis 这些框架如何用反射实现解耦和通用能力，你对 Java 编程的理解也会更上一层楼。
   最后记住一句话：反射是一把利器，合理使用能让代码优雅灵活，滥用则会带来性能和维护灾难。