Java反射机制详解：原理、应用与实战

一、反射机制概述

Java反射(Reflection)是Java语言的一个强大特性，它允许程序在运行时(Runtime)获取类的信息并操作类或对象的属性、方法等。反射机制打破了Java的封装性，但也提供了极大的灵活性。

反射的核心思想：在运行时而非编译时动态获取类型信息，并能够动态调用方法和访问属性。

反射的主要用途包括：

在运行时分析类的能力
在运行时查看对象
实现通用的数组操作代码
利用Method对象实现方法调用

二、反射基础：Class类

在Java中，每个类都有一个对应的Class对象，这个对象包含了与类有关的所有信息。获取Class对象有三种主要方式：

// 1. 通过类名.class获取
Class<String> stringClass = String.class;// 2. 通过对象.getClass()获取
String str = "Hello";
Class<?> strClass = str.getClass();// 3. 通过Class.forName()动态加载
Class<?> arrayListClass = Class.forName("java.util.ArrayList");

三、获取类的信息

通过Class对象，我们可以获取类的各种信息：

1. 获取类的基本信息

Class<?> clazz = Class.forName("java.util.ArrayList");// 获取类名
System.out.println("类名: " + clazz.getName());       // 全限定名
System.out.println("简单类名: " + clazz.getSimpleName());// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println("父类: " + superClass.getName());// 获取实现的接口
Class<?>[] interfaces = clazz.getInterfaces();
System.out.println("实现的接口:");
for (Class<?> interfaceClass : interfaces) {System.out.println(interfaceClass.getName());
}// 获取修饰符
int modifiers = clazz.getModifiers();
System.out.println("修饰符: " + Modifier.toString(modifiers));

2. 获取构造方法

Constructor<?>[] constructors = clazz.getDeclaredConstructors();
System.out.println("构造方法:");
for (Constructor<?> constructor : constructors) {System.out.println(constructor);
}// 获取特定参数类型的构造方法
Constructor<?> constructor = clazz.getConstructor(Collection.class);

四、创建对象实例

通过反射创建对象实例主要有两种方式：

1. 使用Class.newInstance()

Class<?> clazz = Class.forName("java.util.Date");
Object date = clazz.newInstance();  // 调用无参构造方法
System.out.println(date);

注意：此方法在Java 9后已被标记为过时，推荐使用Constructor.newInstance()

2. 使用Constructor.newInstance()

Class<?> clazz = Class.forName("java.util.ArrayList");
Constructor<?> constructor = clazz.getConstructor(int.class);
List<?> list = (List<?>) constructor.newInstance(10);  // 创建初始容量为10的ArrayList
System.out.println("List大小: " + list.size());

五、操作成员属性

1. 获取字段信息

Class<?> clazz = Class.forName("com.example.Person");
Field[] fields = clazz.getDeclaredFields();  // 获取所有字段(包括私有)
System.out.println("字段列表:");
for (Field field : fields) {System.out.println(field.getName() + " - " + field.getType());
}

2. 访问和修改字段值

class Person {private String name;public int age;
}// 获取并修改public字段
Person person = new Person();
Class<?> clazz = person.getClass();Field ageField = clazz.getField("age");
ageField.set(person, 25);
System.out.println("年龄: " + ageField.get(person));// 访问private字段需要设置可访问性
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);  // 突破private限制
nameField.set(person, "张三");
System.out.println("姓名: " + nameField.get(person));

六、调用方法

1. 获取方法信息

Class<?> clazz = Class.forName("java.util.ArrayList");
Method[] methods = clazz.getDeclaredMethods();
System.out.println("方法列表:");
for (Method method : methods) {System.out.println(method.getName() + " - 参数: " + Arrays.toString(method.getParameterTypes()));
}

2. 调用方法

List<String> list = new ArrayList<>();
Class<?> clazz = list.getClass();// 调用add方法
Method addMethod = clazz.getMethod("add", Object.class);
addMethod.invoke(list, "Hello");
addMethod.invoke(list, "World");// 调用size方法
Method sizeMethod = clazz.getMethod("size");
int size = (int) sizeMethod.invoke(list);
System.out.println("列表大小: " + size);  // 输出2// 调用私有方法需要设置可访问性
Method privateMethod = clazz.getDeclaredMethod("privateMethod");
privateMethod.setAccessible(true);
privateMethod.invoke(list);

七、反射的高级应用

1. 动态代理

反射是实现Java动态代理的基础：

interface Hello {void sayHello();
}class HelloImpl implements Hello {public void sayHello() {System.out.println("Hello World");}
}class DynamicProxy implements InvocationHandler {private Object target;public DynamicProxy(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;}
}// 使用动态代理
Hello hello = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(),new Class<?>[] {Hello.class},new DynamicProxy(new HelloImpl())
);
hello.sayHello();

2. 注解处理

反射可以用于运行时处理注解：

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {String value();
}@MyAnnotation("Test Class")
class MyClass {@MyAnnotation("Test Method")public void myMethod() {}
}// 处理注解
Class<?> clazz = MyClass.class;
MyAnnotation classAnnotation = clazz.getAnnotation(MyAnnotation.class);
System.out.println("类注解: " + classAnnotation.value());Method method = clazz.getMethod("myMethod");
MyAnnotation methodAnnotation = method.getAnnotation(MyAnnotation.class);
System.out.println("方法注解: " + methodAnnotation.value());

八、反射的性能考虑

反射虽然强大，但也有一些缺点需要注意：

性能开销：反射操作比直接调用慢，因为涉及动态解析
安全限制：反射需要运行时权限
破坏封装：可以访问私有成员，可能破坏代码的封装性

性能优化建议：

缓存Class对象，避免重复查找
缓存Method/Field/Constructor对象
对于高频调用的方法，考虑使用MethodHandle代替反射

// 使用MethodHandle提升性能
class MyClass {public void myMethod(String s) {System.out.println(s);}
}MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodType type = MethodType.methodType(void.class, String.class);
MethodHandle mh = lookup.findVirtual(MyClass.class, "myMethod", type);MyClass obj = new MyClass();
mh.invokeExact(obj, "Hello MethodHandle");