JAVA基础—关于Java的反射机制

squirrelmoney

已于 2024-03-18 23:18:58 修改

阅读量895

点赞数 17

文章标签： java 开发语言

于 2024-03-18 23:16:51 首次发布

本文链接：https://blog.csdn.net/tanmoney/article/details/136823425

版权

1. Java的反射机制是什么？

反射(reflection)
当我们谈及反射，可以将其比作正在照镜子的行为。就像你可以在禁止中看到自己的反射一样，程序在运行时可以检查自身的机构和行为。这意味这程序可以动态地了解自己地组成部分，比如类、方法和字段，并且可以在运行时修改这些组成部分。这种能力使得程序可以更加灵活和动态地适应不同的需求和情况。
从概念上理解，反射是一种程序在运行时可以检查和修改自身结构的能力。
Java反射机制的主要特点和用法
1. 获取Class对象：通过类的全限定名、对象的 getClass() 方法或 Class 类的静态方法获取类的 Class 对象。
2. 实例化对象：可以使用 Class 对象的 newInstance() 方法来实例化一个类的对象。在 Java 9 中，newInstance() 方法已经被标记为废弃（deprecated），推荐使用其他方式来实例化对象。
3. 获取字段信息：可以使用 Class 对象的 getFields()、getDeclaredFields() 方法获取类的公共和所有字段信息，并使用 Field 对象来访问和修改字段的值。
4. 获取方法信息：可以使用 Class 对象的 getMethods()、getDeclaredMethods() 方法获取类的公共和所有方法信息，并使用 Method 对象来调用方法。
5. 调用方法：可以使用 Method 对象的 invoke() 方法来调用一个方法。
6. 访问私有成员：通过 setAccessible(true) 方法可以访问类的私有成员。
7. 泛型操作：可以通过 Class 对象获取类的泛型信息。
8. 动态代理：反射机制可以用于实现动态代理，可以在运行时动态地创建代理类并处理方法调用。
9. 性能问题：反射操作会带来一定的性能开销，应该谨慎使用，尽量避免在性能敏感的代码中过度使用反射。

2. 反射的核心：Class类

看看JAVA源码中Class类中的注解

Instances of the class Class represent classes and interfaces in a running Java application. An enum type and a record type are kinds of class; an annotation type is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions.
类 Class 的实例表示运行中的 Java 应用程序中的类和接口。枚举类型和记录类型是类的一种；注解类型是接口的一种。每个数组也属于一个类，该类被反映为一个 Class 对象，该对象由具有相同元素类型和维数的所有数组共享。
The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.
原始 Java 类型（boolean、byte、char、short、int、long、float 和 double）以及关键字 void 也表示为 Class 对象。
Class has no public constructor. Instead a Class object is constructed automatically by the Java Virtual Machine when a class loader invokes one of the defineClass methods and passes the bytes of a class file.
Class 没有公共构造函数。相反，当类加载器调用 defineClass 方法之一并传递类文件的字节时，Java 虚拟机会自动构造一个 Class 对象。
The methods of class Class expose many characteristics of a class or interface. Most characteristics are derived from the class file that the class loader passed to the Java Virtual Machine. A few characteristics are determined by the class loading environment at run time, such as the module returned by getModule().
Class 类的方法公开了类或接口的许多特征。大多数特征都源自类加载器传递给 Java 虚拟机的类文件。一些特征由运行时的类加载环境决定，例如由 getModule() 返回的模块。
Some methods of class Class expose whether the declaration of a class or interface in Java source code was enclosed within another declaration. Other methods describe how a class or interface is situated in a nest. A nest is a set of classes and interfaces, in the same run-time package, that allow mutual access to their private members. The classes and interfaces are known as nestmates. One nestmate acts as the nest host, and enumerates the other nestmates which belong to the nest; each of them in turn records it as the nest host. The classes and interfaces which belong to a nest, including its host, are determined when class files are generated, for example, a Java compiler will typically record a top-level class as the host of a nest where the other members are the classes and interfaces whose declarations are enclosed within the top-level class declaration.
Class 类的一些方法公开了在 Java 源代码中类或接口的声明是否被包含在另一个声明中。其他方法描述了类或接口如何位于一个嵌套中。嵌套是一个类和接口的集合，在相同的运行时包中，允许彼此访问其私有成员。这些类和接口被称为嵌套成员。一个嵌套成员充当嵌套主机，并枚举属于嵌套的其他嵌套成员；每个嵌套成员依次将其记录为嵌套主机。属于嵌套的类和接口，包括其主机，在生成类文件时确定，例如，Java 编译器通常会将顶级类记录为嵌套的主机，其中其他成员是声明被包含在顶级类声明内部的类和接口。

总结一下上面内容：

Class类的作用：表示运行中的Java引用程序的类和接口，通过Class对象可以获取和操作类的信息。
Class对象的获取：可以通过类的全限定名（类似字符串形式）获取对应的Class对象，也可以通过类的实例对象‘getClass’方法获取。
Class对象的构造：Class类没有公共构造函数，而是由虚拟机在需要时自动构造。
Class对象的特征：Class对象的方法可以获取类或接口的特征，这些特征大部分来自于类加载器加载类文件时传递给虚拟机的信息。换句话说，类加载器在加载类文件时会提供一些关于类的信息，这些信息包括类的结构、方法、字段等，而这些信息可以通过class对象的方法获取。

Class对象和嵌套：Class对象的一些方法可以用来描述类或接口在嵌套中的情况，嵌套是一组允许互相访问私有成员的类和接口的集合。

在Java中，嵌套是指一组类和接口，它们在同一个运行时包（runtime package）中，并且允许彼此访问私有成员（private members）。这些类和接口被称为嵌套成员（nest members），其中一个嵌套成员充当嵌套主机（nest host），并且枚举了属于该嵌套的其他嵌套成员。通过Class对象的方法，我们可以了解类或接口在嵌套中的位置和关系，以及它们之间如何互相访问私有成员。

举个例子：
当一个类A中包含了另一个类B，而类B又包含了类C，这种情况就构成了嵌套结构。在这个例子中，类A就是嵌套结构的主要部分，而类B和类C是嵌套在类A中的成员。

public class A {
    private class B {
        private class C {
            public void methodC() {
                System.out.println("This is methodC");
            }
        }
    }
}

在这个例子中，类A包含了类B，类B包含了类C。现在我们可以使用反射来探索这个嵌套结构：

	public class Main {
    public static void main(String[] args) throws Exception {
        Class<?> classA = A.class;
        Class<?> classB = A.B.class;
        Class<?> classC = A.B.C.class;

        System.out.println("Class A: " + classA.getName());
        System.out.println("Class B: " + classB.getName());
        System.out.println("Class C: " + classC.getName());

        // 获取类B中的所有成员类（嵌套成员）
        Class<?>[] nestMembersOfB = classB.getNestMembers();
        System.out.println("Nest members of B:");
        for (Class<?> member : nestMembersOfB) {
            System.out.println("- " + member.getName());
        }

        // 获取类C的嵌套主机（即类B）
        Class<?> nestHostOfC = classC.getNestHost();
        System.out.println("Nest host of C: " + nestHostOfC.getName());
    }
}

3. 整理一下问题

我们可以通过Class类做什么？
Class类主要作用是允许程序在运行时获取类信息，并通过反射机制实例化对象、访问和修改类的字段、调用类的方法等。
我们要怎么获取Class类的对象？
使用.class语法；
调用对象的getClass()方法；
使用Class.forName()方法。

怎么修改一个字段值？

import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) throws Exception {
        MyClass myObject = new MyClass("Hello, world!");
        System.out.println("Before modification: " + myObject.getMyField());

        Field field = MyClass.class.getDeclaredField("myField");
        field.setAccessible(true); // 设置字段为可访问，因为 myField 是私有字段
        field.set(myObject, "Modified value");

        System.out.println("After modification: " + myObject.getMyField());
    }
}

这段代码通过getDeclaredField()获取了私有字段 myField 的 Field 对象，并通过 setAccessible(true) 方法设置了字段的可访问性，因为 myField 是私有字段。最后，我们使用 field.set(myObject, “Modified value”) 将 myField 的值修改为 “Modified value”。

Class类的常用方法？
- getName()：获取类的名称。
- getModifiers()：获取类的修饰符。
- getSuperclass()：获取类的父类。
- getInterfaces()：获取类实现的接口数组。
- getField(String name)：获取指定名称的公共字段。
- getMethod(String name, Class<?>… - parameterTypes)：获取指定名称和参数类型的公共方法。
- newInstance()：通过无参构造方法实例化一个对象（已过时）。
怎么通过反射调用方法？
使用 Method 对象的 invoke() 方法来调用一个方法。

反射机制用在动态代理？
动态代理是一种利用反射机制在运行时创建代理类的技术。在 Java 中，可以使用 java.lang.reflect.Proxy 类来创建动态代理。动态代理通常用于在不修改源代码的情况下对方法调用进行额外的处理，比如添加日志、性能监控、事务管理等。
下面是一个简单的示例，展示了如何使用动态代理：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义一个接口
interface MyInterface {
    void myMethod();
}

// 实现接口的类
class MyClass implements MyInterface {
    public void myMethod() {
        System.out.println("Real object method");
    }
}

// 实现 InvocationHandler 接口，用于处理方法调用
class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass realObject = new MyClass();
        MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(
                realObject.getClass().getClassLoader(),
                realObject.getClass().getInterfaces(),
                new MyInvocationHandler(realObject));

        proxyObject.myMethod();
    }
}

在这个示例中，我们定义了一个接口 MyInterface 和一个实现类 MyClass。然后，我们使用 Proxy.newProxyInstance() 方法创建了一个动态代理对象 proxyObject，并通过 MyInvocationHandler 来处理方法调用。在 MyInvocationHandler 中，我们在调用实际方法前后添加了额外的逻辑。最后，我们通过动态代理对象调用方法，实际上会调用到 MyInvocationHandler 中的 invoke 方法，从而实现了对方法调用的动态处理。