一、反射机制原理
1. 核心原理
反射允许程序在运行时动态地：
-
获取类的完整信息（类名、方法、字段、注解等）
-
创建对象实例
-
调用方法和访问字段
-
修改字段值（包括私有字段）
2. 实现机制
java
复制
下载
// Class对象的获取方式
// 1. 类名.class
Class<?> clazz1 = String.class;
// 2. 对象.getClass()
String str = "hello";
Class<?> clazz2 = str.getClass();
// 3. Class.forName() - 最常用
Class<?> clazz3 = Class.forName("java.lang.String");
// 4. ClassLoader加载
ClassLoader loader = Thread.currentThread().getContextClassLoader();
Class<?> clazz4 = loader.loadClass("java.lang.String");3. 类加载与Class对象
java
复制
下载
// Class对象包含类的元数据
public final class Class<T> {
// 类名
private final String name;
// 方法信息
private Method[] methods;
// 字段信息
private Field[] fields;
// 构造方法
private Constructor<?>[] constructors;
// 注解信息
private Annotation[] annotations;
// 父类
private Class<? super T> superclass;
}4. 内存模型
text
复制
下载
JVM方法区（元空间） 堆内存
┌─────────────────┐ ┌─────────────┐
│ 类的元数据 │ │ Class对象 │
│ - 方法字节码 │◄───│ - 指向元数据 │
│ - 字段描述符 │ │ - 静态变量 │
│ - 常量池 │ └─────────────┘
└─────────────────┘ ▲
▲ │
│ ┌───┴────┐
│ │ 实例对象 │
└──────────────────┤ - 字段值 │
└─────────┘二、核心API详解
1. 获取类信息
java
复制
下载
Class<?> clazz = User.class;
// 获取类名
String className = clazz.getName(); // 全限定名: "com.example.User"
String simpleName = clazz.getSimpleName(); // 简单名: "User"
// 获取包信息
Package pkg = clazz.getPackage();
String packageName = pkg.getName();
// 获取修饰符
int modifiers = clazz.getModifiers();
Modifier.isPublic(modifiers); // 是否是public
Modifier.isAbstract(modifiers); // 是否是abstract
// 获取父类和接口
Class<?> superClass = clazz.getSuperclass();
Class<?>[] interfaces = clazz.getInterfaces();
// 获取注解
Annotation[] annotations = clazz.getAnnotations();
MyAnnotation myAnno = clazz.getAnnotation(MyAnnotation.class);2. 操作字段（Field）
java
复制
下载
class User {
private String name;
public int age;
private static final String COUNTRY = "China";
}
// 获取字段
Field[] fields = clazz.getDeclaredFields(); // 所有字段（包括private）
Field publicField = clazz.getField("age"); // 仅public字段
// 获取/设置字段值
User user = new User();
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true); // 突破private限制
// 读取值
Object value = nameField.get(user); // 获取name值
// 设置值
nameField.set(user, "张三"); // 设置name为"张三"
// 静态字段操作
Field countryField = clazz.getDeclaredField("COUNTRY");
countryField.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(countryField, countryField.getModifiers() & ~Modifier.FINAL);
countryField.set(null, "USA"); // 修改final静态字段（不推荐）3. 操作方法（Method）
java
复制
下载
class Calculator {
public int add(int a, int b) { return a + b; }
private void log(String message) { System.out.println(message); }
}
// 获取方法
Method[] methods = clazz.getDeclaredMethods();
Method addMethod = clazz.getDeclaredMethod("add", int.class, int.class);
Method logMethod = clazz.getDeclaredMethod("log", String.class);
// 调用方法
Calculator calc = new Calculator();
Object result = addMethod.invoke(calc, 10, 20); // 返回30
// 调用私有方法
logMethod.setAccessible(true);
logMethod.invoke(calc, "test message");
// 静态方法调用
Method staticMethod = clazz.getDeclaredMethod("staticMethod");
staticMethod.invoke(null); // 静态方法传null4. 操作构造器（Constructor）
java
复制
下载
class Person {
private String name;
private int age;
public Person() {}
private Person(String name) { this.name = name; }
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
// 获取构造器
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
Constructor<?> defaultConstructor = clazz.getDeclaredConstructor(); // 无参
Constructor<?> paramConstructor = clazz.getDeclaredConstructor(String.class, int.class);
// 创建实例
Person p1 = (Person) defaultConstructor.newInstance();
Person p2 = (Person) paramConstructor.newInstance("张三", 25);
// 创建私有构造器的实例
Constructor<?> privateConstructor = clazz.getDeclaredConstructor(String.class);
privateConstructor.setAccessible(true);
Person p3 = (Person) privateConstructor.newInstance("李四");三、应用场景
1. 框架开发（最常用）
java
复制
下载
// Spring IOC容器实现原理示例
public class SimpleContainer {
private Map<String, Object> beans = new HashMap<>();
public void register(Class<?> clazz) throws Exception {
// 通过注解获取Bean名称
Component anno = clazz.getAnnotation(Component.class);
String beanName = anno != null ? anno.value() :
clazz.getSimpleName().toLowerCase();
// 创建实例（支持依赖注入）
Object bean = createInstance(clazz);
beans.put(beanName, bean);
}
private Object createInstance(Class<?> clazz) throws Exception {
// 1. 获取所有构造方法
Constructor<?>[] constructors = clazz.getConstructors();
// 2. 选择@Autowired标注的构造方法
for (Constructor<?> constructor : constructors) {
if (constructor.isAnnotationPresent(Autowired.class)) {
// 3. 获取参数类型
Class<?>[] paramTypes = constructor.getParameterTypes();
Object[] params = new Object[paramTypes.length];
// 4. 递归创建参数实例
for (int i = 0; i < paramTypes.length; i++) {
params[i] = getBean(paramTypes[i]);
}
// 5. 创建实例
return constructor.newInstance(params);
}
}
// 6. 使用默认构造方法
return clazz.newInstance();
}
}
// 使用注解定义Bean
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Component {
String value() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
@interface Autowired {}2. 动态代理
java
复制
下载
// JDK动态代理（基于接口）
public class DynamicProxyHandler implements InvocationHandler {
private Object target;
public DynamicProxyHandler(Object target) {
this.target = target;
}
public Object createProxy() {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this
);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 前置处理
System.out.println("Before method: " + method.getName());
// 调用目标方法
Object result = method.invoke(target, args);
// 后置处理
System.out.println("After method: " + method.getName());
return result;
}
}
// 使用示例
interface UserService {
void save(User user);
}
class UserServiceImpl implements UserService {
public void save(User user) {
// 业务逻辑
}
}
// 创建代理
UserService proxy = (UserService) new DynamicProxyHandler(new UserServiceImpl()).createProxy();
proxy.save(user);篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案
【点击此处即可/免费获取】
3. 注解处理器
java
复制
下载
// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface LogExecutionTime {
}
// 注解处理器
public class LogExecutionTimeProcessor {
public static void process(Object obj) throws Exception {
Class<?> clazz = obj.getClass();
for (Method method : clazz.getDeclaredMethods()) {
if (method.isAnnotationPresent(LogExecutionTime.class)) {
// 创建代理方法
Method originalMethod = method;
// 动态生成代理类（简化示例）
System.out.println("Logging execution time for: " + method.getName());
long startTime = System.currentTimeMillis();
originalMethod.invoke(obj);
long endTime = System.currentTimeMillis();
System.out.println("Execution time: " + (endTime - startTime) + "ms");
}
}
}
}
// 使用
class Service {
@LogExecutionTime
public void processData() {
// 耗时操作
}
}4. 配置文件映射
java
复制
下载
// properties文件：config.properties
// database.url=jdbc:mysql://localhost:3306/test
// database.username=root
// database.password=123456
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface ConfigValue {
String key();
}
class DatabaseConfig {
@ConfigValue(key = "database.url")
private String url;
@ConfigValue(key = "database.username")
private String username;
@ConfigValue(key = "database.password")
private String password;
// getters and setters
}
public class ConfigLoader {
public static <T> T load(Class<T> clazz, Properties props) throws Exception {
T instance = clazz.newInstance();
for (Field field : clazz.getDeclaredFields()) {
ConfigValue annotation = field.getAnnotation(ConfigValue.class);
if (annotation != null) {
String value = props.getProperty(annotation.key());
if (value != null) {
field.setAccessible(true);
// 类型转换
Object convertedValue = convertValue(value, field.getType());
field.set(instance, convertedValue);
}
}
}
return instance;
}
private static Object convertValue(String value, Class<?> targetType) {
if (targetType == String.class) return value;
if (targetType == int.class || targetType == Integer.class)
return Integer.parseInt(value);
if (targetType == boolean.class || targetType == Boolean.class)
return Boolean.parseBoolean(value);
// 其他类型转换...
return value;
}
}5. ORM框架
java
复制
下载
// 简易ORM实现
public class SimpleORM {
public static <T> T queryOne(Class<T> clazz, String sql, Object... params) throws Exception {
// 执行SQL获取ResultSet
ResultSet rs = executeQuery(sql, params);
if (rs.next()) {
T instance = clazz.newInstance();
// 获取ResultSetMetaData
ResultSetMetaData metaData = rs.getMetaData();
int columnCount = metaData.getColumnCount();
for (int i = 1; i <= columnCount; i++) {
String columnName = metaData.getColumnLabel(i);
Object columnValue = rs.getObject(i);
// 使用反射设置字段值
Field field = findField(clazz, columnName);
if (field != null) {
field.setAccessible(true);
field.set(instance, columnValue);
}
}
return instance;
}
return null;
}
private static Field findField(Class<?> clazz, String columnName) {
// 支持驼峰转换：user_name -> userName
String fieldName = toCamelCase(columnName);
try {
return clazz.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
// 查找父类字段
if (clazz.getSuperclass() != null) {
return findField(clazz.getSuperclass(), columnName);
}
return null;
}
}
}6. 插件化系统
java
复制
下载
// 插件接口
interface Plugin {
void execute();
String getName();
}
// 插件管理器
public class PluginManager {
private List<Plugin> plugins = new ArrayList<>();
public void loadPlugins(String pluginDir) throws Exception {
File dir = new File(pluginDir);
for (File jarFile : dir.listFiles((d, name) -> name.endsWith(".jar"))) {
// 创建自定义ClassLoader
URLClassLoader loader = new URLClassLoader(
new URL[]{jarFile.toURI().toURL()},
getClass().getClassLoader()
);
// 读取插件配置
Properties props = new Properties();
try (InputStream is = loader.getResourceAsStream("plugin.properties")) {
props.load(is);
}
String className = props.getProperty("main.class");
if (className != null) {
// 加载插件类
Class<?> pluginClass = loader.loadClass(className);
// 检查是否实现了Plugin接口
if (Plugin.class.isAssignableFrom(pluginClass)) {
Plugin plugin = (Plugin) pluginClass.newInstance();
plugins.add(plugin);
}
}
}
}
public void executeAll() {
for (Plugin plugin : plugins) {
plugin.execute();
}
}
}7. 序列化/反序列化
java
复制
下载
public class JsonSerializer {
public static String toJson(Object obj) throws IllegalAccessException {
if (obj == null) return "null";
Class<?> clazz = obj.getClass();
// 处理基本类型
if (clazz.isPrimitive() || isWrapperType(clazz)) {
return obj.toString();
}
// 处理String
if (clazz == String.class) {
return "\"" + obj + "\"";
}
// 处理数组
if (clazz.isArray()) {
return arrayToJson(obj);
}
// 处理集合
if (Collection.class.isAssignableFrom(clazz)) {
return collectionToJson((Collection<?>) obj);
}
// 处理Map
if (Map.class.isAssignableFrom(clazz)) {
return mapToJson((Map<?, ?>) obj);
}
// 处理普通对象
return objectToJson(obj);
}
private static String objectToJson(Object obj) throws IllegalAccessException {
StringBuilder json = new StringBuilder("{");
Class<?> clazz = obj.getClass();
Field[] fields = clazz.getDeclaredFields();
boolean first = true;
for (Field field : fields) {
field.setAccessible(true);
Object value = field.get(obj);
if (value != null) {
if (!first) json.append(",");
json.append("\"").append(field.getName()).append("\":")
.append(toJson(value));
first = false;
}
}
json.append("}");
return json.toString();
}
}四、性能考虑
1. 性能对比
java
复制
下载
// 直接调用 vs 反射调用
public class PerformanceTest {
private static final int LOOP_COUNT = 1000000;
public void directCall() {
User user = new User();
for (int i = 0; i < LOOP_COUNT; i++) {
user.getName(); // 直接调用
}
}
public void reflectionCall() throws Exception {
User user = new User();
Class<?> clazz = user.getClass();
Method method = clazz.getMethod("getName");
for (int i = 0; i < LOOP_COUNT; i++) {
method.invoke(user); // 反射调用
}
}
public void optimizedReflection() throws Exception {
User user = new User();
Class<?> clazz = user.getClass();
Method method = clazz.getMethod("getName");
method.setAccessible(true); // 关闭访问检查
for (int i = 0; i < LOOP_COUNT; i++) {
method.invoke(user);
}
}
}篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案
【点击此处即可/免费获取】
2. 性能优化方案
java
复制
下载
// 1. 缓存Class对象和Method对象
class MethodCache {
private static final Map<String, Method> METHOD_CACHE = new ConcurrentHashMap<>();
public static Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)
throws NoSuchMethodException {
String key = clazz.getName() + "#" + methodName;
return METHOD_CACHE.computeIfAbsent(key, k -> {
try {
Method method = clazz.getMethod(methodName, paramTypes);
method.setAccessible(true);
return method;
} catch (Exception e) {
throw new RuntimeException(e);
}
});
}
}
// 2. 使用MethodHandle（Java 7+）
public class MethodHandleExample {
public static void main(String[] args) throws Throwable {
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle mh = lookup.findVirtual(String.class, "length",
MethodType.methodType(int.class));
String str = "hello";
int length = (int) mh.invokeExact(str); // 性能接近直接调用
}
}
// 3. 使用Unsafe（不推荐，绕过安全检查）
public class UnsafeExample {
private static final Unsafe unsafe;
private static final long nameOffset;
static {
try {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
unsafe = (Unsafe) theUnsafe.get(null);
nameOffset = unsafe.objectFieldOffset(User.class.getDeclaredField("name"));
} catch (Exception e) {
throw new Error(e);
}
}
public static void setUserName(User user, String name) {
unsafe.putObject(user, nameOffset, name);
}
}五、安全考虑
1. 安全管理器
java
复制
下载
// 启用安全管理器限制反射
System.setSecurityManager(new SecurityManager() {
@Override
public void checkMemberAccess(Class<?> clazz, int which) {
// 禁止访问私有成员
if (which == Member.PRIVATE) {
throw new SecurityException("Access to private members is not allowed");
}
}
@Override
public void checkPackageAccess(String pkg) {
// 禁止访问某些包
if (pkg.startsWith("sun.") || pkg.startsWith("com.sun.")) {
throw new SecurityException("Access to " + pkg + " is not allowed");
}
}
});2. 安全使用建议
java
复制
下载
// 1. 避免过度使用setAccessible(true)
Field field = clazz.getDeclaredField("secret");
// field.setAccessible(true); // 谨慎使用
// 2. 限制可反射的类
public class SafeReflection {
private static final Set<String> ALLOWED_CLASSES = new HashSet<>(
Arrays.asList("com.example.User", "com.example.Product")
);
public static Class<?> safeForName(String className) throws ClassNotFoundException {
if (!ALLOWED_CLASSES.contains(className)) {
throw new SecurityException("Class not allowed: " + className);
}
return Class.forName(className);
}
}
// 3. 使用MethodHandles.Lookup限制访问
MethodHandles.Lookup lookup = MethodHandles.privateLookupIn(
TargetClass.class, MethodHandles.lookup()
);
// 只能访问TargetClass的私有成员六、总结
适用场景：
-
框架开发：Spring、MyBatis等
-
动态代理：AOP、RPC、事务管理
-
注解处理：自定义注解处理器
-
配置文件映射：属性文件到对象的映射
-
ORM框架：数据库结果集到对象的映射
-
插件系统：动态加载和执行插件
-
序列化：JSON/XML序列化
-
测试框架：JUnit的@Test注解处理
-
代码生成：动态生成类和方法
不适用场景：
-
性能敏感：高频调用的核心业务逻辑
-
简单场景：可以直接调用的简单方法
-
安全敏感：需要严格控制访问权限的场景
-
类型安全要求高：编译时类型检查重要的场景
最佳实践：
-
缓存反射对象：Class、Method、Field、Constructor
-
最小化setAccessible(true)：只在必要时使用
-
考虑性能开销：避免在循环中使用反射
-
提供安全边界：限制可反射的类和成员
-
使用替代方案：考虑MethodHandle、LambdaMetafactory等
-
错误处理：妥善处理NoSuchMethodException等异常
反射是Java强大的特性，但也是一把双刃剑。合理使用可以极大提高代码的灵活性和可扩展性，滥用则会导致性能问题和安全隐患。