Java反射机制详解-优快云博客

本文深入探讨Java反射机制，包括类加载的区别、三种类加载方式、生成对象步骤、通过反射获取对象中的变量和方法，以及使用反射创建BeanUtil工具类等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.类加载的区别：

1.1 RTTI

Run-Time Type Identification 通过运行时类型信息程序能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际派生类型。

1.2 反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。

2.三种类加载的方式

2.1 类.class

Class personClazz = Person.class;

2.2 实例.getClass();

Person person = new Person();

Class personClazz1 = person.getClass();

2.3 Class.forName("类的全路径名");

Class personClazz2 = Class.forName("com.xxx.Person");

上述三种方式得到的Class对比出来的结果完全一致，说明加载的是同一个class文件得到的。

3.生成对象的步骤

3.1 Person person = new Person();

直接new出来的对象，经历了三个步骤：

3.1.1 编译期加载Person.class文件；

3.1.2 查找构造函数Person()；

3.1.3 通过构造函数Person()创建对象

3.2 通过反射生成对象

3.2.1 Class personClazz = Class.forName("com.xxx.Person");

运行期加载Person.class文件

3.2.2 Constructor constructor= personClazz.getConstructor();

创建构造函数Person()

3.2.3 Person person = (Person) constructor.newlnstance();

通过构造函数Person()创建对象

4.通过反射获取对象中的变量和方法

4.1 获取构造方法

前提：先获取到对应的class，见章节2

例： Class personClazz = Class.forName("com.xxx.Person");

4.1.1 获取无参构造

Constructor constructor1 = personClazz.getConstructor();

创建对象：Person person1 = (Person) constructor1.newInstance();

4.1.2 获取有参构造

传入的是可变参数，注意传入的类型是有参构造方法的参数类型

Constructor constructor2 = personClazz.getConstructor(String.class, Integer.class, Byte.class, Boolean.class);

创建对象：Person person2 = (Person) constructor2.newInstance("aa", 10, (byte) 1, true); 需要与上面一一对应

4.1.3 暴力反射获取私有构造方法

//懒汉式单例模式
public class SingletonPerson {
    private static final SingletonPerson instance = new SingletonPerson();
    private SingletonPerson(){
    }
    public static SingletonPerson getInstance(){
        return instance;
    }
}

Class singletonPersonClazz = SingletonPerson.class;
Constructor constructor3 = singletonPersonClazz.getConstructor();
Constructor constructor3 = singletonPersonClazz.getDeclaredConstructor();
constructor3.setAccessible(true);
SingletonPerson singletonPerson = (SingletonPerson) constructor3.newInstance();  //false
SingletonPerson singletonPerson1 = SingletonPerson.getInstance();  //false
SingletonPerson singletonPerson2 = SingletonPerson.getInstance();  //true

说明暴力反射确实成功破坏了单例模式，创建了新的实例，此时可进行改造，在单例的构造方法中抛出异常，如下所示：

//懒汉式单例模式增强版
public class SingletonPerson {
    private static final SingletonPerson instance = new SingletonPerson();
    private SingletonPerson(){
        throw new RuntimeException("小辣鸡，还想搞偷袭！");
    }
    public static SingletonPerson getInstance(){
        return instance;
    }
}

4.1.4 getxxx与getDeclaredxxx的说明

xxx可以是constructor，filed，method

getxxx只能获取public的，包括从父类继承来的字段。如果是非public，会报java.lang.NoSuchFieldException: xxx

getDeclaredxxx可以获取本类所有的字段，包括private的，但是不能获取继承来的字段。 (注：这里只能获取到private的字段，但并不能访问该private字段的值, 除非加上setAccessible(true))

所以，一般情况下除非获取父类的属性，都使用getDeclaredxxx，同时搭配setAccessible(true)，来确保能够获取到想要的属性。

4.2 获取Field

// 第一步：获得Class
Class personClazz = Person.class;
// 第二步：获得构造方法
Constructor<Person> constructor = personClazz.getConstructor();
Person person = constructor.newInstance(); // 初始化生成Person对象
// 第三步：通过Class对象，获得Field对象  Person[类]的name属性。
Field nameField = personClazz.getField("name");

// 暴力反射，获取private属性
Field sexField = personClazz.getDeclaredField("sex");
sexField.setAccessible(true);

// 第四步：操作Field，获得属性值（第三步已经获取到field对象，这一步获取属性值，需要指定是哪个实例的属性值）
String name = String.valueOf(nameField.get(person));

//field中一些重要的参数
System.out.println("获取字段的类型:" + nameField.getType()); //class java.lang.String
System.out.println("获取字段的名字:" + nameField.getName()); // name
System.out.println("获取字段的访问修饰符:" + Modifier.toString(nameField.getModifiers())); //public
System.out.println("获取字段所在类的全路径:" + nameField.getDeclaringClass().getName()); // com.xxx.Person

//直接打印反射得到的nameField 
System.out.println(nameField); //public java.lang.String com.xxx.Person.name

//直接打印其实是调用了Field.toString();源码如下
public String toString() {
        int mod = getModifiers(); //mod记录了修饰符的类型，Modifier.toString通过与预先设定的类型（16进制表示）进行与运算，如果不为0，拼接对应的类型
        return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            + getType().getTypeName() + " "
            + getDeclaringClass().getTypeName() + "."
            + getName());
    }

4.3 获取method

// 第一步：获得Class
Class personClazz = Person.class;
// 第二步：获得构造方法
Constructor<Person> constructor = personClazz.getConstructor();
Person person = constructor.newInstance(); // 初始化生成Person对象
// Method method = personClazz.getMethod("privateMethod"); // 不能使用getMethod，否则报错：java.lang.NoSuchMethodException:xxx
Method method = personClazz.getDeclaredMethod("privateMethod");
method.setAccessible(true); // 必须设置为true
//使用method.invoke(person)进行调用实例中的方法
System.out.println("private方法：privateMethod()=" + method.invoke(person));

5.使用反射创建一个beanUtil

原因：为了解耦，需要在不同层之间进行实体的转换，基础设施层的PO（persistent），领域层（Domain entity、VO（value）），应用层（DTO/ entity），视图层（VO（view）/UO）；可以使用反射创建一个工具类完成转换

public class BeanUtils {

    public static void convertor(Object originObj, Object targetObj) throws Throwable {
        // 第一步，获得class对象
        Class orginClazz = originObj.getClass();
        Class targetClazz = targetObj.getClass();

        // 第二步，获得Field
        Field[] orginFields = orginClazz.getDeclaredFields();
        Field[] targetFields = targetClazz.getDeclaredFields();

        // 第三步：赋值
        for (Field originField : orginFields) {
            for (Field targetField : targetFields) {
                if (originField.getName().equals(targetField.getName())) {
                    originField.setAccessible(true);
                    targetField.setAccessible(true);
                    targetField.set(targetObj, originField.get(originObj));
                }
            }
        }
    }
}

具有同样的功能的还有springframework.beans.BeanUtils.copyProperties(Object source, Object target); mapstruct等。

**************此文章只是本人学习过程中的学习笔记，不做其他用途，如果有其他意见，欢迎一起讨论，谢谢，侵删*************************