当前位置：首页 > article >正文

java 反射详解

article 2024/12/4 16:02:32

Java 反射详解

Java 反射（Reflection） 是 Java 提供的一种功能强大的机制，允许程序在运行时动态地获取类的结构信息（如类的属性、方法、构造函数等），并可以直接操作对象、调用方法、修改属性值等。反射是实现框架、工具类和动态代理的基础。

1. 反射的定义与作用

1.1 什么是反射？

反射：Java 中的一种机制，可以让程序在运行时查看和操作类的成员（属性、方法、构造函数等）。
核心思想：将编译时的类型检查转移到运行时。

1.2 反射的作用

动态加载类、创建对象。
动态调用类的方法或操作属性。
实现框架和工具（如 Spring、MyBatis 等）。
提高程序的灵活性和动态性。

2. 反射的基本使用

2.1 获取 `Class` 对象

在反射中，Class 对象是所有反射操作的起点。Java 提供了三种方式获取 Class 对象：

通过类名获取：
```
Class<?> clazz = ClassName.class;
```

通过对象获取：

Object obj = new ClassName();
Class<?> clazz = obj.getClass();

通过类的全限定名加载：

Class<?> clazz = Class.forName("com.example.ClassName");

2.2 反射的核心类

java.lang.Class：表示类的信息。
java.lang.reflect.Field：表示类的属性。
java.lang.reflect.Method：表示类的方法。
java.lang.reflect.Constructor：表示类的构造函数。

2.3 常用反射操作

2.3.1 获取类的信息

Class<?> clazz = Class.forName("java.util.ArrayList");

// 获取类的名称
System.out.println(clazz.getName());          // 全限定名
System.out.println(clazz.getSimpleName());    // 简单类名

// 获取类的修饰符
int modifiers = clazz.getModifiers();
System.out.println(Modifier.isPublic(modifiers)); // 是否为 public

// 获取类的包名
Package pkg = clazz.getPackage();
System.out.println(pkg.getName());

2.3.2 获取类的属性

Class<?> clazz = Class.forName("com.example.Person");

// 获取所有属性
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
    System.out.println("属性名称：" + field.getName());
    System.out.println("属性类型：" + field.getType().getName());
    System.out.println("修饰符：" + Modifier.toString(field.getModifiers()));
}

2.3.3 操作属性

通过反射可以对类的属性进行读写操作。

Class<?> clazz = Class.forName("com.example.Person");
Object obj = clazz.getDeclaredConstructor().newInstance();

// 获取指定属性
Field field = clazz.getDeclaredField("name");
field.setAccessible(true); // 设置可访问（忽略私有属性的访问限制）

// 修改属性值
field.set(obj, "John Doe");

// 获取属性值
String value = (String) field.get(obj);
System.out.println("属性值：" + value);

2.3.4 获取类的方法

Class<?> clazz = Class.forName("com.example.Person");

// 获取所有方法
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
    System.out.println("方法名称：" + method.getName());
    System.out.println("返回类型：" + method.getReturnType().getName());
    System.out.println("参数类型：" + Arrays.toString(method.getParameterTypes()));
}

2.3.5 调用方法

Class<?> clazz = Class.forName("com.example.Person");
Object obj = clazz.getDeclaredConstructor().newInstance();

// 获取方法
Method method = clazz.getDeclaredMethod("setName", String.class);
method.setAccessible(true); // 设置可访问

// 调用方法
method.invoke(obj, "John Doe");

2.3.6 获取构造函数

Class<?> clazz = Class.forName("com.example.Person");

// 获取所有构造函数
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
for (Constructor<?> constructor : constructors) {
    System.out.println("构造函数：" + constructor.getName());
    System.out.println("参数类型：" + Arrays.toString(constructor.getParameterTypes()));
}

2.3.7 调用构造函数

Class<?> clazz = Class.forName("com.example.Person");

// 获取无参构造函数
Constructor<?> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true); // 设置可访问

// 创建实例
Object obj = constructor.newInstance();

3. 动态代理

反射的一个重要应用是动态代理，它允许在运行时动态创建代理类。

3.1 JDK 动态代理

import java.lang.reflect.*;

interface HelloService {
    void sayHello();
}

class HelloServiceImpl implements HelloService {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        HelloService target = new HelloServiceImpl();

        // 创建代理对象
        HelloService proxy = (HelloService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxyObj, method, methodArgs) -> {
                System.out.println("Before method invoke");
                Object result = method.invoke(target, methodArgs);
                System.out.println("After method invoke");
                return result;
            }
        );

        // 调用代理方法
        proxy.sayHello();
    }
}