Java反射（Reflection）：运行时类信息操作 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java反射：一场与类信息的“私奔”之旅，带你玩转运行时魔法 🧙‍♂️

各位观众老爷们，大家好！我是你们的老朋友，人称“代码界段子手”的程序猿小明。今天，咱们不聊高并发，不谈微服务，而是要来一场刺激的，充满神秘感的“私奔”之旅—— Java反射！

相信很多小伙伴一听到“反射”这两个字，脑袋里就浮现出一堆晦涩难懂的术语，什么Class对象、Field、Method、Constructor… 瞬间感觉自己回到了高中课堂，只想赶紧溜之大吉 🏃。

别慌！今天，小明就带你拨开云雾见青天，用最通俗易懂的语言，最生动形象的比喻，让你彻底搞懂Java反射，甚至爱上它！

Part 1：什么是反射？为什么要“私奔”？ 🤔

首先，我们来回答一个最基本的问题：什么是反射？

想象一下，你是一个侦探，手里只有一张照片，你想知道照片里的人是谁，住在哪里，有什么爱好… 但你不能直接问他，只能通过各种线索，抽丝剥茧，最终找到答案。

Java反射，就相当于程序界的“侦探”。它允许我们在程序运行时，动态地获取一个类的信息，包括它的属性（Field）、方法（Method）、构造器（Constructor）等等，甚至可以动态地创建对象、调用方法、修改属性值！

所以，与其说反射是“Reflection”，不如说它是“Re-Inspection”——重新审视。

那么，我们为什么要“私奔”，啊不，要学习反射呢？难道正常情况下，我们不能直接通过类名来访问这些信息吗？

答案是：可以，但不灵活！

想象一下，你写了一个通用框架，需要处理各种各样的类。这些类可能是你提前不知道的，甚至是用户自定义的。如果不用反射，你就需要针对每一种类编写不同的代码，这简直就是程序员的噩梦 😱！

而反射，就像一个万能钥匙，可以打开任何类的大门，让你在运行时动态地处理它们。

用人话说，反射的优点就是：

灵活性高：可以处理运行时才知道的类，实现动态加载和调用。
可扩展性强：方便框架和工具的设计，可以处理各种类型的对象。
解耦性好：降低代码之间的依赖关系，提高代码的可维护性。

当然，反射也不是万能的。它也有一些缺点：

性能开销大：反射操作涉及到动态类型检查和方法查找，比直接调用慢很多。
安全性问题：反射可以绕过访问权限检查，可能会破坏封装性。
代码可读性差：反射代码通常比较复杂，难以理解和维护。

所以，在使用反射的时候，一定要慎重考虑，权衡利弊。

Part 2：反射的核心API：三大法宝 ⚔️

要玩转反射，就必须掌握它的核心API。这里，小明为你总结了反射的三大法宝：

Class类：所有反射操作的入口。你可以通过Class对象获取类的各种信息。
Field类：表示类的属性。你可以通过Field对象获取和修改属性的值。
Method类：表示类的方法。你可以通过Method对象调用方法。
Constructor类：表示类的构造器。你可以通过Constructor对象创建对象。

下面，我们就来逐一介绍这三大法宝。

1. Class类：反射的“身份证” 🆔

Class类是反射的基石，它是所有反射操作的入口。你可以把Class对象想象成一个类的“身份证”，通过它，你可以了解一个类的所有信息。

获取Class对象的方式有很多种：

通过类名：Class<?> clazz = MyClass.class;
通过对象：Class<?> clazz = myObject.getClass();
通过类名字符串：Class<?> clazz = Class.forName("com.example.MyClass"); (这个最灵活，但是要注意处理异常)

拿到Class对象之后，你就可以开始你的侦探之旅了！你可以通过它获取：

类的名称：clazz.getName() (完整类名，包含包名)
类的简单名称：clazz.getSimpleName() (不包含包名)
类的修饰符：clazz.getModifiers() (返回一个int值，可以使用Modifier类来解析，例如 Modifier.isPublic(modifiers))
类的父类：clazz.getSuperclass()
类实现的接口：clazz.getInterfaces()
类的所有属性：clazz.getDeclaredFields() (包括私有属性) clazz.getFields() (只包括公共属性)
类的所有方法：clazz.getDeclaredMethods() (包括私有方法) clazz.getMethods() (只包括公共方法)
类的所有构造器：clazz.getDeclaredConstructors() (包括私有构造器) clazz.getConstructors() (只包括公共构造器)
类的注解：clazz.getAnnotations()

举个栗子 🌰：

import java.lang.reflect.*;

public class ClassInfo {

    public static void main(String[] args) throws ClassNotFoundException {
        // 获取 Class 对象
        Class<?> clazz = Class.forName("com.example.Person");

        // 获取类名
        System.out.println("类名：" + clazz.getName());
        System.out.println("简单类名：" + clazz.getSimpleName());

        // 获取修饰符
        int modifiers = clazz.getModifiers();
        System.out.println("修饰符：" + Modifier.toString(modifiers));

        // 获取父类
        Class<?> superClass = clazz.getSuperclass();
        System.out.println("父类：" + superClass.getName());

        // 获取接口
        Class<?>[] interfaces = clazz.getInterfaces();
        System.out.println("接口：");
        for (Class<?> anInterface : interfaces) {
            System.out.println("  " + anInterface.getName());
        }

        // 获取属性
        Field[] fields = clazz.getDeclaredFields();
        System.out.println("属性：");
        for (Field field : fields) {
            System.out.println("  " + Modifier.toString(field.getModifiers()) + " " + field.getType().getSimpleName() + " " + field.getName());
        }

        // 获取方法
        Method[] methods = clazz.getDeclaredMethods();
        System.out.println("方法：");
        for (Method method : methods) {
            System.out.println("  " + Modifier.toString(method.getModifiers()) + " " + method.getReturnType().getSimpleName() + " " + method.getName() + "()");
        }

        // 获取构造器
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        System.out.println("构造器：");
        for (Constructor<?> constructor : constructors) {
            System.out.println("  " + Modifier.toString(constructor.getModifiers()) + " " + clazz.getSimpleName() + "()");
        }
    }
}

// 一个简单的 Person 类
package com.example;

interface Walkable {
    void walk();
}

class Animal {
    public String species;
}

class Person extends Animal implements Walkable{
    private String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private void sayHello() {
        System.out.println("Hello, my name is " + name);
    }

    public int getAge() {
        return age;
    }

    @Override
    public void walk() {
        System.out.println("Person is walking");
    }
}

运行结果（假设 Person 类位于 com.example 包下）：

类名：com.example.Person
简单类名：Person
修饰符：class
父类：com.example.Animal
接口：
  com.example.Walkable
属性：
  private String name
  public int age
  public String species
方法：
  public int getAge()
  public void walk()
  private void sayHello()
构造器：
  public Person()
  public public Person()

2. Field类：属性的“操控杆” 🕹️

Field类代表一个类的属性。通过Field对象，你可以获取属性的名称、类型、修饰符，甚至可以读取和修改属性的值！

要获取Field对象，你可以通过clazz.getDeclaredField(fieldName) (获取指定名称的属性，包括私有属性) 或 clazz.getField(fieldName) (获取指定名称的公共属性) 方法。

拿到Field对象之后，你可以：

获取属性的名称：field.getName()
获取属性的类型：field.getType()
获取属性的修饰符：field.getModifiers()
读取属性的值：field.get(object) (object是类的实例)
设置属性的值：field.set(object, value)

注意：如果属性是私有的，你需要先调用field.setAccessible(true) 才能访问它。这就像侦探获得了搜查令，才能进入私宅搜查。

举个栗子 🌰：

import java.lang.reflect.Field;

public class FieldExample {

    public static void main(String[] args) throws Exception {
        // 获取 Class 对象
        Class<?> clazz = Class.forName("com.example.Person");

        // 创建 Person 对象
        Object person = clazz.newInstance();

        // 获取 name 属性
        Field nameField = clazz.getDeclaredField("name");
        nameField.setAccessible(true); // 允许访问私有属性

        // 设置 name 属性的值
        nameField.set(person, "张三");

        // 获取 age 属性
        Field ageField = clazz.getField("age");

        // 设置 age 属性的值
        ageField.set(person, 20);

        // 获取 name 和 age 的值
        String name = (String) nameField.get(person);
        int age = ageField.getInt(person);

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

运行结果：

Name: 张三
Age: 20

3. Method类：方法的“遥控器” 🎮

Method类代表一个类的方法。通过Method对象，你可以获取方法的名称、参数类型、返回类型、修饰符，甚至可以调用方法！

要获取Method对象，你可以通过clazz.getDeclaredMethod(methodName, parameterTypes) (获取指定名称和参数类型的方法，包括私有方法) 或 clazz.getMethod(methodName, parameterTypes) (获取指定名称和参数类型的公共方法) 方法。

拿到Method对象之后，你可以：

获取方法的名称：method.getName()
获取方法的参数类型：method.getParameterTypes()
获取方法的返回类型：method.getReturnType()
获取方法的修饰符：method.getModifiers()
调用方法：method.invoke(object, arguments) (object是类的实例，arguments是参数列表)

注意：如果方法是私有的，你需要先调用method.setAccessible(true) 才能访问它。这就像侦探获得了窃听器，才能监听私密对话。

举个栗子 🌰：

import java.lang.reflect.Method;

public class MethodExample {

    public static void main(String[] args) throws Exception {
        // 获取 Class 对象
        Class<?> clazz = Class.forName("com.example.Person");

        // 创建 Person 对象
        Object person = clazz.newInstance();

        // 获取 sayHello 方法
        Method sayHelloMethod = clazz.getDeclaredMethod("sayHello");
        sayHelloMethod.setAccessible(true); // 允许访问私有方法

        // 调用 sayHello 方法
        sayHelloMethod.invoke(person);

        // 获取 getAge 方法
        Method getAgeMethod = clazz.getMethod("getAge");

        // 设置 age 属性，否则 getAge 返回默认值 0
        Field ageField = clazz.getField("age");
        ageField.set(person, 30);

        // 调用 getAge 方法
        int age = (int) getAgeMethod.invoke(person);

        System.out.println("Age: " + age);
    }
}

运行结果：

Hello, my name is null  // 因为 name 没有设置，所以是 null
Age: 30

4. Constructor类：对象的“制造机” 🏭

Constructor类代表一个类的构造器。通过Constructor对象，你可以获取构造器的参数类型、修饰符，甚至可以创建对象！

要获取Constructor对象，你可以通过clazz.getDeclaredConstructor(parameterTypes) (获取指定参数类型的构造器，包括私有构造器) 或 clazz.getConstructor(parameterTypes) (获取指定参数类型的公共构造器) 方法。

拿到Constructor对象之后，你可以：

获取构造器的参数类型：constructor.getParameterTypes()
获取构造器的修饰符：constructor.getModifiers()
创建对象：constructor.newInstance(arguments) (arguments是参数列表)

注意：如果构造器是私有的，你需要先调用constructor.setAccessible(true) 才能访问它。

举个栗子 🌰：

import java.lang.reflect.Constructor;

public class ConstructorExample {

    public static void main(String[] args) throws Exception {
        // 获取 Class 对象
        Class<?> clazz = Class.forName("com.example.Person");

        // 获取带参数的构造器
        Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);

        // 创建 Person 对象
        Object person = constructor.newInstance("李四", 25);

        // 获取 name 和 age 属性
        Field nameField = clazz.getDeclaredField("name");
        nameField.setAccessible(true);
        Field ageField = clazz.getField("age");

        // 获取 name 和 age 的值
        String name = (String) nameField.get(person);
        int age = ageField.getInt(person);

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

运行结果：

Name: 李四
Age: 25

Part 3：反射的应用场景：大显神通 💪

掌握了反射的基本API，接下来我们来看看反射在实际开发中的应用场景。

框架开发：很多框架，例如Spring、MyBatis，都大量使用了反射。它们通过反射来动态地加载类、创建对象、注入依赖、调用方法，从而实现高度的灵活性和可扩展性。
动态代理：动态代理是AOP（面向切面编程）的基础。通过反射，我们可以动态地生成代理类，并在方法调用前后添加额外的逻辑，例如日志记录、权限校验、事务管理等等。
单元测试：在单元测试中，我们经常需要访问类的私有属性和方法。反射可以让我们绕过访问权限的限制，方便我们进行测试。
对象序列化和反序列化：在对象序列化和反序列化过程中，我们需要访问对象的属性。反射可以让我们方便地读取和设置对象的属性值。
IDE和调试器：IDE和调试器使用反射来显示对象的属性和方法，方便开发者进行调试。

举个栗子 🌰：Spring IoC容器

Spring IoC容器就是一个典型的使用反射的例子。当你使用@Autowired注解来注入依赖的时候，Spring会利用反射来：

扫描你的类，找到带有@Autowired注解的属性。
根据属性的类型，在IoC容器中查找对应的Bean。
利用反射将Bean注入到属性中。

这个过程是完全动态的，不需要你手动编写任何代码，这就是反射的魅力！

Part 4：反射的注意事项：小心驶得万年船 🚢

虽然反射很强大，但是在使用的时候也要注意一些问题：

性能问题：反射操作的性能开销比较大，尽量避免在性能敏感的场景中使用。可以考虑使用缓存来提高性能。
安全问题：反射可以绕过访问权限检查，可能会破坏封装性。要谨慎使用setAccessible(true) 方法，避免泄露敏感信息。
异常处理：反射操作可能会抛出各种异常，例如ClassNotFoundException、NoSuchMethodException、IllegalAccessException、InvocationTargetException等等。要做好异常处理，避免程序崩溃。
代码可读性：反射代码通常比较复杂，难以理解和维护。要编写清晰的代码，添加必要的注释，方便他人阅读和维护。

Part 5：总结：与反射共舞 💃

好了，各位观众老爷们，今天的Java反射之旅就到这里了。希望通过今天的讲解，你已经对Java反射有了更深入的理解。

反射就像一把双刃剑，用得好可以让你事半功倍，用不好可能会让你陷入困境。所以，在使用反射的时候，一定要慎重考虑，权衡利弊。

记住，反射不是万能的，但没有反射是万万不能的 😎！

最后，祝大家编程愉快，代码无Bug！下次再见！ 💖

Java反射：一场与类信息的“私奔”之旅，带你玩转运行时魔法 🧙‍♂️

发表回复 取消回复

发表回复取消回复