【Java 反射机制】详解-CSDN博客

本文链接：https://blog.csdn.net/MISSXIAOJJ/article/details/144797687

Java 反射

无套路、关注即可领。持续更新中
关注公众号：搜【架构研究站】 回复：资料领取，即可获取全部面试题以及1000+份学习资料

在 Java
编程领域，反射机制是一项极为强大且重要的特性，它赋予了程序在运行时动态获取类的信息以及操作类、对象、方法、属性等元素的能力。通过反射，Java
代码能够突破传统编译时确定结构的限制，实现更为灵活和动态化的编程。接下来，我们将深入到源码层面，详细剖析 Java
反射机制的实现原理、性能特点以及应用场景。

一、Java 反射机制概述

Java 反射机制主要位于 java.lang.reflect 包中，它提供了一系列的类和接口，使得程序员可以在运行时获取类的构造函数、方法、字段等信息，并能够调用方法、访问和修改字段的值等操作。核心的类包括 Class、Constructor、Method 和 Field，它们分别对应着类本身、类的构造函数、类的方法以及类的字段（成员变量）。反射机制的存在打破了常规编程中代码结构相对静态的局限，为诸如框架开发、插件化架构、动态代理等高级应用场景提供了有力支持。

二、Class 类 - 反射的入口

1. 实现原理（源码解读）

Class 类是整个反射机制的核心入口点，每个类在 Java 虚拟机（JVM）中都有且仅有一个对应的 Class 对象来表示它。

以下是部分关键源码解读：

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {

    // 类的名称（包含包名）
    private final String name;

    // 类的修饰符，例如 public、abstract 等，通过位运算来表示和解析
    private final int modifiers;

    // 类的直接父类的 Class 对象，如果是 Object 类则为 null
    private final Class<? super T> superclass;

    // 类实现的接口的 Class 对象数组
    private final Class<?>[] interfaces;

    // 用于存储类的静态字段（成员变量），以字段名作为键，Field 对象作为值的映射表（内部实现为哈希表等结构）
    private transient volatile Map<String, Field> declaredFields;

    // 用于存储类的方法，以方法签名（包含方法名、参数类型等关键信息）作为键，Method 对象作为值的映射表（内部实现为合适的查找结构）
    private transient volatile Map<String, Method> declaredMethods;

    // 用于存储类的构造函数，以构造函数签名（包含参数类型等关键信息）作为键，Constructor 对象作为值的映射表（内部实现为便于查找的结构）
    private transient volatile Map<String, Constructor<T>> declaredConstructors;

    // 通过类加载器加载类并获取对应的 Class 对象的静态方法，这是获取 Class 对象的常见方式之一
    public static Class<?> forName(String className) throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

    private static native Class<?> forName0(String name, boolean initialize, ClassLoader loader,
                                             Class<?> caller) throws ClassNotFoundException;

    // 获取类的名称（包含包名）的方法
    public String getName() {
        return name;
    }

    // 获取类的修饰符的方法，返回的是 int 类型，通过位运算相关操作可以解析出具体的修饰符情况
    public int getModifiers() {
        return modifiers;
    }

    // 获取类的直接父类的 Class 对象的方法
    public Class<? super T> getSuperclass() {
        return superclass;
    }

    // 获取类实现的接口的 Class 对象数组的方法
    public Class<?>[] getInterfaces() {
        return interfaces;
    }

    // 获取类声明的所有字段（包括私有字段）的方法，内部会从 declaredFields 映射表中查找并返回 Field 对象数组
    public Field[] getDeclaredFields() {
        return getDeclaredFields0(false);
    }

    private Field[] getDeclaredFields0(boolean publicOnly) {
        // 省略部分内部逻辑，主要是从 declaredFields 映射表中根据条件筛选并返回 Field 对象数组
        // 会涉及到对字段的访问权限等相关判断和处理
        return result;
    }

    // 获取类声明的所有方法（包括私有方法）的方法，类似地从 declaredMethods 映射表中查找并返回 Method 对象数组
    public Method[] getDeclaredMethods() {
        return getDeclaredMethods0(false);
    }

    private Method[] getDeclaredMethods0(boolean publicOnly) {
        // 省略部分内部逻辑，主要是从 declaredMethods 映射表中根据条件筛选并返回 Method 对象数组
        // 会涉及到对方法的访问权限等相关判断和处理
        return result;
    }

    // 获取类声明的所有构造函数的方法，从 declaredConstructors 映射表中查找并返回 Constructor 对象数组
    public Constructor<T>[] getDeclaredConstructors() {
        return getDeclaredConstructors0(false);
    }

    private Constructor<T>[] getDeclaredConstructors0(boolean publicOnly) {
        // 省略部分内部逻辑，主要是从 declaredConstructors 映射表中根据条件筛选并返回 Constructor 对象数组
        // 会涉及到对构造函数的访问权限等相关判断和处理
        return result;
    }
}

从源码可以看出，Class 类内部维护了诸多关于类自身的关键信息，如类名、修饰符、父类、接口以及通过映射表存储的字段、方法、构造函数等元素对应的对象信息。forName 方法是常用的获取 Class 对象的途径，它通过底层的本地方法 forName0（借助 JNI 与 JVM 底层交互）实现类的加载并返回对应的 Class 对象。而获取各类成员（字段、方法、构造函数）的方法，则是基于内部维护的映射表进行查找和筛选，依据不同的访问权限等条件返回相应的对象数组，以此来提供给外部代码获取类的详细信息的能力。

2. 性能特点

类加载性能：首次使用 Class.forName 等方式加载类时，会涉及到类的加载、验证、准备、解析等一系列 JVM 层面的操作，这是相对耗时的过程，特别是在处理复杂的类层次结构或者大量类加载的情况下。不过，一旦类被加载后，后续对该 Class 对象的访问和操作（如获取成员信息等）就不会再重复这些加载过程，性能会有所提升。
获取成员信息性能：获取类的字段、方法、构造函数等成员信息时，由于内部是基于映射表进行查找（虽然有一定的缓存和优化机制），但随着类的成员数量增多以及频繁地调用获取操作（比如循环多次获取不同类的大量方法信息），还是会存在一定的性能开销，尤其是对于那些成员众多且复杂的大型类。

3. 应用场景

数据库连接框架：在如 Hibernate 等数据库连接框架中，需要根据配置文件中指定的数据库驱动类名动态加载对应的驱动类，这时就会使用 Class.forName 来加载类，使得框架能够在运行时灵活适配不同的数据库环境，而不需要在编译时就确定具体的数据库驱动依赖。
插件化架构：开发插件化的应用时，主应用程序事先并不知道插件中具体的类结构和功能，通过反射机制可以在运行时加载插件中的类，获取其方法和属性等信息，进而调用插件提供的功能，实现插件的动态加载和扩展应用功能的目的。

三、Constructor 类 - 操作构造函数

1. 实现原理（源码解读）

Constructor 类用于表示类的构造函数，通过它可以在反射机制下创建类的对象实例。

关键源码解读：

public final class Constructor<T> implements java.io.Serializable,
                                         GenericDeclaration,
                                         Type,
                                         AnnotatedElement {

    // 所属的 Class 对象，即该构造函数所属的类
    private final Class<T> declaringClass;

    // 构造函数的参数类型数组，用于确定构造函数的签名
    private final Class<?>[] parameterTypes;

    // 构造函数的修饰符，同样通过位运算表示和解析
    private final int modifiers;

    // 通过构造函数创建对象实例的方法，内部会进行参数类型匹配、权限检查等一系列操作后调用底层的实例化逻辑
    public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException,
                                                   IllegalArgumentException, InvocationTargetException {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(declaringClass, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM)!= 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

    // 获取构造函数所属的 Class 对象的方法
    public Class<T> getDeclaringClass() {
        return declaringClass;
    }

    // 获取构造函数的参数类型数组的方法
    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    // 获取构造函数的修饰符的方法
    public int getModifiers() {
        return modifiers;
    }
}

从源码来看，Constructor 类保存了所属类、参数类型以及修饰符等关键构造函数相关信息。核心的 newInstance 方法用于创建对象实例，在这个过程中，它首先会进行访问权限的检查（通过 Reflection.quickCheckMemberAccess 等方法判断当前调用环境是否有权限调用该构造函数），对于枚举类型的类还会进行特殊判断（禁止通过反射创建枚举对象），然后获取 ConstructorAccessor（这是实际执行实例化操作的内部对象，它的获取可能涉及到缓存机制等复杂逻辑），最后通过它来创建并返回对应的对象实例。

2. 性能特点

对象创建性能：通过反射使用 Constructor 的 newInstance 方法创建对象实例相比于直接使用 new 关键字创建对象要慢很多。这是因为反射创建对象时，除了要进行常规的实例化操作外，还需要进行权限检查、参数类型匹配以及涉及到内部复杂的获取 ConstructorAccessor 等逻辑，存在较多的额外开销，尤其是在频繁创建对象的场景下，性能差异会更加明显。
与构造函数复杂度的关联：构造函数的参数数量、类型复杂度等因素也会影响反射创建对象的性能。参数越多、类型越复杂（比如涉及到复杂的泛型类型等），在进行参数匹配和实例化过程中需要的处理时间就越长，进而导致整体创建对象的速度变慢。

3. 应用场景

依赖注入框架：像 Spring 框架中的依赖注入功能，在创建 bean 对象时，有时需要根据配置信息（例如指定了构造函数参数等情况）动态地通过反射找到对应的构造函数并创建对象实例，以实现灵活的对象装配，满足不同的应用配置需求。
动态对象创建：在一些动态生成对象的场景中，例如根据用户输入的类名和构造函数参数信息，通过反射找到对应的构造函数并创建对象，实现程序在运行时根据外部条件灵活生成不同类型的对象实例。

四、Method 类 - 调用类的方法

1. 实现原理（源码解读）

Method 类用于表示类的方法，通过它可以在反射机制下调用类的方法，无论是公有还是私有方法都可以进行操作。

以下是部分关键源码解读：

public final class Method implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {

    // 所属的 Class 对象，即该方法所属的类
    private final Class<?> declaringClass;

    // 方法的名称
    private final String name;

    // 方法的参数类型数组，用于确定方法的签名
    private final Class<?>[] parameterTypes;

    // 方法的返回类型
    private final Class<?> returnType;

    // 方法的修饰符，通过位运算表示和解析
    private final int modifiers;

    // 通过反射调用方法的核心方法，内部会进行权限检查、参数类型匹配、方法查找等一系列操作后调用底层的执行逻辑
    public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException,
                                                       InvocationTargetException {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(declaringClass, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, name, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

    // 获取方法所属的 Class 对象的方法
    public Class<?> getDeclaringClass() {
        return declaringClass;
    }

    // 获取方法的名称的方法
    public String getName() {
        return name;
    }

    // 获取方法的参数类型数组的方法
    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    // 获取方法的返回类型的方法
    public Class<?>[] getReturnType() {
        return returnType;
    }

    // 获取方法的修饰符的方法
    public int getModifiers() {
        return modifiers;
    }
}

从源码角度分析，Method 类存储了所属类、方法名、参数类型、返回类型以及修饰符等重要信息。关键的 invoke 方法用于调用对应的方法，在调用前会先进行访问权限的检查（类似构造函数的权限判断机制），然后获取 MethodAccessor（它是实际执行方法调用的内部对象，其获取涉及缓存等相关逻辑），最后通过它来执行方法调用并返回结果。

2. 性能特点

方法调用性能：通过反射使用 Method 的 invoke 方法调用类的方法，相较于直接在代码中调用方法（常规的方法调用在编译时已经确定了调用关系和地址等信息），性能会差很多。这是因为反射调用方法时需要进行权限检查、查找方法匹配（根据方法签名进行参数类型等匹配）以及获取 MethodAccessor 等额外操作，这些操作带来了较多的开销，特别是在频繁调用方法的场景下，性能损耗会更加显著。
与方法复杂度的关联：方法的参数数量、返回值类型复杂度以及方法体内部逻辑的复杂程度等都会影响反射调用的性能。参数多、返回值类型复杂（比如涉及复杂的自定义对象类型作为返回值）以及方法体执行耗时较长的情况下，反射调用时除了自身的额外开销外，还要等待方法体执行完成，整体性能会受到较大影响。

3. 应用场景

测试框架：像 JUnit 等测试框架，在运行测试用例时，需要动态地调用被测试类的各个测试方法（这些方法可能有不同的参数、修饰符等情况），通过反射机制可以获取这些方法并进行调用，而不需要为每个测试方法都编写特定的调用代码，实现了自动化的测试用例执行。
AOP（面向切面编程）：在 AOP 框架中，需要在目标类的方法执行前后动态地插入一些额外的逻辑（如日志记录、事务管理等），通过反射获取目标方法并在其调用前后进行相应操作，实现了不修改目标类原始代码的情况下添加额外功能的效果。

五、Field 类 - 访问和修改类的字段

1. 实现原理（源码解读）

Field 类用于表示类的字段（成员变量），通过它可以在反射机制下访问和修改类的字段值，不管是公有还是私有字段都能操作。

以下是关键源码解读：

public final class Field implements java.io.Serializable,
                             AnnotatedElement {

    // 所属的 Class 对象，即该字段所属的类
    private final Class<?> declaringClass;

    // 字段的名称
    private final String name;

    // 字段的类型
    private final Class<?> type;

    // 字段的修饰符，通过位运算表示和解析
    private final int modifiers;

    // 获取字段值的方法，内部会进行权限检查等操作后从对象实例中获取对应字段的值（通过底层的内存访问等机制）
    public Object get(Object obj) throws IllegalAccessException {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(declaringClass, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, name, modifiers);
            }
        }
        return getFieldAccessor(obj).get(obj);
    }

    // 设置字段值的方法，内部会进行权限检查等操作后将指定的值设置到对象实例的对应字段中（涉及到底层的内存写入等操作）
    public void set(Object obj, Object value) throws IllegalAccessException {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(declaringClass, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, name, modifiers);
            }
        }
        getFieldAccessor(obj).set(obj, value);
    }

    // 获取字段所属的 Class 对象的方法
    public Class<?> getDeclaringClass() {
        return declaringClass;
    }

    // 获取字段的名称的


    // 获取字段的名称的方法
    public String getName() {
        return name;
    }

    // 获取字段的类型的方法
    public Class<?> getType() {
        return type;
    }

    // 获取字段的修饰符的方法
    public int getModifiers() {
        return modifiers;
    }
}

从源码可以看出，Field类中记录着所属类、字段名称、字段类型以及修饰符这些关键信息，它们共同确定了一个类中的具体字段情况。

在get方法中，当尝试获取字段值时，首先会进行访问权限方面的检查，通过Reflection.quickCheckMemberAccess判断当前调用环境是否有权限访问该字段，如果没有权限（比如访问私有字段时不符合相应规则），还会进一步通过checkAccess等方法进行更细致的权限验证，只有在权限验证通过后，才会借助getFieldAccessor方法获取到对应的FieldAccessor对象（这个对象负责实际从对象实例对应的内存位置获取字段值的底层操作，其内部实现会根据不同的字段类型等情况有相应的内存读取逻辑），进而通过它来获取到字段的值。
set方法用于设置字段的值，也是先执行类似的权限检查流程，确保当前调用环境有权力对该字段进行修改操作，之后通过getFieldAccessor获取到相应的FieldAccessor对象，再利用这个对象执行将指定值写入到对象实例对应内存位置（也就是该字段所在位置）的操作，完成字段值的设置，这里涉及到底层的内存写入机制，需要严格遵循 Java 内存模型以及对象内存布局等相关规则，确保数据的正确性和一致性。

2. 性能特点

字段访问与修改性能：通过反射使用Field类的get和set方法来访问、修改字段值，相较于直接在代码中通过对象实例访问公有字段（如obj.fieldName这种常规方式）或者通过公有方法（如果是私有字段通过对应的公有获取和设置方法来操作），性能是比较低的。这是因为反射操作字段时每次都要进行权限检查，还要经过获取FieldAccessor等一系列逻辑处理，存在较多的额外开销，尤其在频繁地访问或者修改字段值的场景下，这种性能损耗会更加明显。
与字段类型及访问权限关联：字段本身的类型复杂度会对性能有影响，例如对于基本数据类型的字段，在内存读取和写入操作相对简单直接一些，而对于复杂的对象类型字段，可能涉及到更多的内存管理以及对象状态维护等操作，会使反射操作耗时更长。另外，访问权限方面，如果是私有字段，反射机制需要突破常规的访问限制，在权限检查等环节会有更多的处理步骤，相比于公有字段的反射操作会更耗时。

3. 应用场景

对象序列化与反序列化：在一些自定义的序列化框架或者特定的对象持久化场景中，需要将对象的各个字段值提取出来进行存储（序列化），之后又能根据存储的信息还原对象（反序列化），通过反射的Field类可以遍历对象的所有字段（无论公有私有），获取其值进行序列化操作，再通过设置字段值来重建对象，实现灵活的对象状态保存和恢复，不受限于对象中字段的访问权限等因素。
对象属性的动态修改：例如在某些配置类加载场景下，根据配置文件中的配置项动态地修改对应对象的属性值。可能事先并不知道具体要修改哪个对象的哪些字段，但可以通过反射获取类的Field对象，然后根据配置项的指示来设置相应字段的值，实现程序在运行时按照外部配置灵活调整对象的内部状态，增强了程序的灵活性和可配置性。

六、整体性能综合分析

综合来看，Java 反射机制虽然赋予了程序极大的灵活性，但从性能角度确实存在一定的代价。与常规的、编译时就确定好的代码操作（如直接实例化对象、调用方法、访问公有字段等）相比，反射操作在每次执行时基本都要涉及到权限检查、查找匹配（构造函数、方法基于签名匹配，字段基于名称和类型等匹配）以及获取对应的内部访问对象（如ConstructorAccessor、MethodAccessor、FieldAccessor等）这些额外的步骤，这些操作都会消耗额外的时间和资源，尤其在以下几种情况中性能问题会更加凸显：

1. 频繁操作场景

当需要在循环或者高频率调用的代码块中频繁地使用反射进行对象创建（通过Constructor）、方法调用（通过Method）或者字段访问修改（通过Field）时，由于每次调用都伴随着上述那些额外开销，性能的损耗会随着调用次数的增加而快速累积，使得整体程序执行效率明显下降，相比直接编写对应的非反射代码的执行速度可能会慢数倍甚至更多，具体取决于操作的复杂度和硬件环境等因素。

2. 复杂类结构场景

对于那些有着大量成员（众多构造函数、方法、字段）的复杂类而言，反射机制在获取类的相关信息（比如通过Class类获取所有方法、所有字段等操作）时，内部基于映射表等结构进行查找筛选的成本会增加，而且后续针对这些众多成员进行反射操作（调用方法、创建对象、访问字段等）时，同样面临更多的匹配和权限检查等工作，也会进一步拖慢程序的运行速度，使得在处理这类复杂类结构时反射机制的性能劣势更加显著。

在很多实际应用场景中，反射机制所带来的灵活性优势往往超过了对性能的这点考量，并且通过合理的设计和优化（比如缓存反射获取到的关键对象，减少重复获取操作；在非频繁调用的关键节点使用反射等），可以在一定程度上缓解性能方面的问题，使其在保障程序灵活性的同时也能维持在可接受的性能水平。

七、应用场景总结与拓展

1. 框架开发

Spring 框架：作为 Java 开发中极为常用的框架，Spring 大量运用了反射机制。在其核心的依赖注入（DI）功能里，通过反射来动态查找并实例化 bean 对象（利用Constructor类找到合适的构造函数创建对象），解析配置文件或者注解中指定的属性注入信息，再通过Field类将依赖的对象注入到对应的 bean 中；同时，在 AOP（面向切面编程）方面，借助反射的Method类在目标方法执行前后动态插入切面逻辑（如事务管理、日志记录等），实现了不修改原始业务代码却能增强功能的效果，极大地提升了代码的可维护性和扩展性。
Hibernate 框架：在处理数据库持久化操作时，Hibernate 需要根据实体类的映射配置（无论是基于 XML 配置还是注解配置）动态地了解类的结构（通过Class类获取字段等信息），生成对应的 SQL 语句来操作数据库，例如将对象的字段值持久化到数据库表中（通过Field类获取字段值用于构建 SQL 语句中的参数）以及从数据库查询结果构建对象（利用Field类设置字段值来还原对象），反射机制在这里使得 Hibernate 能够支持各种不同结构的实体类与数据库的交互，无需为每个实体类编写特定的数据库操作代码，增强了框架的通用性。

2. 插件化架构

在插件化的应用中，主应用程序本身无法预知插件具体的类结构和功能实现。通过反射机制，主程序可以在运行时加载插件中的类（利用Class.forName等方式），获取插件类的构造函数（通过Constructor类）来创建插件对象实例，调用插件类提供的方法（通过Method类）来执行插件功能，以及访问插件类中定义的字段（通过Field类）来获取或修改相关状态，实现插件的动态加载、卸载以及功能扩展，让应用程序可以像搭积木一样方便地添加各种功能插件，提升了应用的灵活性和可扩展性。

3. 动态代理

在实现动态代理时，例如 Java 自带的java.lang.reflect.Proxy类，会基于反射机制来创建代理对象。代理对象能够在不改变目标对象原有代码的基础上，拦截对目标对象方法的调用（通过反射的Method类获取目标方法信息并在代理中进行额外处理），然后可以在方法调用前后添加一些通用的逻辑，比如权限验证、日志记录等，之后再将调用转发给真正的目标对象执行相应方法，实现了一种非常灵活的对象行为控制和功能增强机制，在分布式系统、远程调用等场景中有着广泛的应用。

4. 测试框架与代码分析工具

JUnit 等测试框架：在执行测试用例时，需要动态地遍历测试类中的各个测试方法（通过Class类获取所有方法并筛选出符合测试规范的方法，通常是带有特定注解标记的方法），然后通过反射的Method类调用这些测试方法，自动执行测试流程并收集测试结果，而无需手动为每个测试方法编写单独的调用代码，大大提高了测试效率以及代码的可维护性，使得单元测试能够更加方便地在项目中推行。
代码分析工具：像一些静态代码分析工具或者代码覆盖率检测工具，需要深入到代码的内部结构，通过反射获取类、方法、字段等各种信息（通过Class类以及其相关的获取成员方法），分析代码的逻辑、调用关系、是否遵循规范等情况，进而生成相应的分析报告，帮助开发人员发现代码中的潜在问题（如未使用的变量、潜在的空指针风险等），提升代码质量。