本文目录导读：
我将为您展示一个完整的Java反射案例,涵盖反射的核心功能和使用场景。
基础实体类
package com.example.reflection;
import java.io.Serializable;
import java.util.Date;
/**
* 用户实体类（用于反射测试）
*/
public class User implements Serializable {
@FieldInfo("用户ID")
private Long id;
@FieldInfo("用户名")
private String username;
@FieldInfo("密码")
private String password;
@FieldInfo("邮箱")
private String email;
private Date createTime;
public static final String DEFAULT_ROLE = "USER";
public User() {}
public User(Long id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
", createTime=" + createTime +
'}';
}
/**
* 自定义方法用于反射演示
*/
public void sayHello(String name) {
System.out.println("Hello, " + name + "! I'm " + this.username);
}
}
自定义注解
package com.example.reflection;
import java.lang.annotation.*;
/**
* 字段信息注解
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldInfo {
String value() default "";
}
反射工具类
package com.example.reflection;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 反射工具类
*/
public class ReflectionUtils {
/**
* 获取类的所有信息
*/
public static void printClassInfo(Class<?> clazz) {
System.out.println("===== 类信息 =====");
System.out.println("类名: " + clazz.getName());
System.out.println("简单类名: " + clazz.getSimpleName());
System.out.println("包名: " + clazz.getPackage().getName());
System.out.println("修饰符: " + Modifier.toString(clazz.getModifiers()));
System.out.println("父类: " + clazz.getSuperclass().getName());
System.out.println("接口:");
for (Class<?> iface : clazz.getInterfaces()) {
System.out.println(" - " + iface.getName());
}
}
/**
* 获取所有字段信息
*/
public static List<Field> getAllFields(Class<?> clazz) {
List<Field> fields = new ArrayList<>();
Class<?> current = clazz;
// 遍历继承链获取所有字段
while (current != null && current != Object.class) {
fields.addAll(Arrays.asList(current.getDeclaredFields()));
current = current.getSuperclass();
}
return fields;
}
/**
* 打印字段信息
*/
public static void printFieldsInfo(Class<?> clazz) {
System.out.println("\n===== 字段信息 =====");
List<Field> fields = getAllFields(clazz);
for (Field field : fields) {
System.out.println("字段名: " + field.getName());
System.out.println("类型: " + field.getType().getName());
System.out.println("修饰符: " + Modifier.toString(field.getModifiers()));
// 检查注解
if (field.isAnnotationPresent(FieldInfo.class)) {
FieldInfo annotation = field.getAnnotation(FieldInfo.class);
System.out.println("注解: " + annotation.value());
}
System.out.println("---");
}
}
/**
* 打印构造方法信息
*/
public static void printConstructorsInfo(Class<?> clazz) {
System.out.println("\n===== 构造方法信息 =====");
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println("构造方法: " + constructor.getName());
System.out.println("修饰符: " + Modifier.toString(constructor.getModifiers()));
System.out.print("参数列表: (");
Class<?>[] params = constructor.getParameterTypes();
for (int i = 0; i < params.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(params[i].getSimpleName());
}
System.out.println(")");
System.out.println("---");
}
}
/**
* 打印方法信息
*/
public static void printMethodsInfo(Class<?> clazz) {
System.out.println("\n===== 方法信息 =====");
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println("方法名: " + method.getName());
System.out.println("返回类型: " + method.getReturnType().getSimpleName());
System.out.println("修饰符: " + Modifier.toString(method.getModifiers()));
System.out.print("参数列表: (");
Class<?>[] params = method.getParameterTypes();
for (int i = 0; i < params.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(params[i].getSimpleName());
}
System.out.println(")");
// 异常信息
Class<?>[] exceptionTypes = method.getExceptionTypes();
if (exceptionTypes.length > 0) {
System.out.println("抛出异常: " + Arrays.toString(exceptionTypes));
}
System.out.println("---");
}
}
/**
* 动态创建对象
*/
public static Object createObject(Class<?> clazz, Object... args) throws Exception {
Constructor<?> constructor = clazz.getDeclaredConstructor(
Arrays.stream(args).map(Object::getClass).toArray(Class[]::new)
);
constructor.setAccessible(true);
return constructor.newInstance(args);
}
/**
* 调用方法（支持私有方法）
*/
public static Object invokeMethod(Object obj, String methodName, Object... args) throws Exception {
Class<?>[] paramTypes = Arrays.stream(args)
.map(Object::getClass)
.toArray(Class[]::new);
Method method = obj.getClass().getDeclaredMethod(methodName, paramTypes);
method.setAccessible(true);
return method.invoke(obj, args);
}
/**
* 设置字段值（支持私有字段）
*/
public static void setField(Object obj, String fieldName, Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
/**
* 获取字段值（支持私有字段）
*/
public static Object getField(Object obj, String fieldName) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
return field.get(obj);
}
}
反射示例演示类
package com.example.reflection;
import java.lang.reflect.Field;
import java.util.Date;
import java.util.List;
public class ReflectionDemo {
public static void main(String[] args) {
try {
// 1. 获取Class对象的三种方式
System.out.println("=== 1. 获取Class对象的三种方式 ===");
Class<?> clazz1 = User.class;
Class<?> clazz2 = Class.forName("com.example.reflection.User");
User user = new User();
Class<?> clazz3 = user.getClass();
System.out.println("方式1: " + clazz1.getName());
System.out.println("方式2: " + clazz2.getName());
System.out.println("方式3: " + clazz3.getName());
System.out.println("三种方式获取的是同一个Class对象: " + (clazz1 == clazz2 && clazz2 == clazz3));
// 2. 打印类信息
System.out.println("\n=== 2. 类信息 ===");
ReflectionUtils.printClassInfo(User.class);
// 3. 打印字段信息
System.out.println("\n=== 3. 字段信息 ===");
ReflectionUtils.printFieldsInfo(User.class);
// 4. 打印构造方法信息
System.out.println("\n=== 4. 构造方法信息 ===");
ReflectionUtils.printConstructorsInfo(User.class);
// 5. 打印方法信息
System.out.println("\n=== 5. 方法信息 ===");
ReflectionUtils.printMethodsInfo(User.class);
// 6. 动态创建对象
System.out.println("\n=== 6. 动态创建对象 ===");
// 使用无参构造
User user1 = (User) ReflectionUtils.createObject(User.class);
System.out.println("无参构造创建: " + user1);
// 使用有参构造
User user2 = (User) ReflectionUtils.createObject(
User.class,
1L, "john", "123456"
);
System.out.println("有参构造创建: " + user2);
// 7. 动态设置和获取字段值
System.out.println("\n=== 7. 动态设置和获取字段值 ===");
User user3 = (User) ReflectionUtils.createObject(User.class);
ReflectionUtils.setField(user3, "id", 100L);
ReflectionUtils.setField(user3, "username", "alice");
ReflectionUtils.setField(user3, "password", "password123");
ReflectionUtils.setField(user3, "email", "alice@example.com");
ReflectionUtils.setField(user3, "createTime", new Date());
Long id = (Long) ReflectionUtils.getField(user3, "id");
String username = (String) ReflectionUtils.getField(user3, "username");
System.out.println("设置后的对象: " + user3);
System.out.println("获取的字段值 - id: " + id + ", username: " + username);
// 8. 调用方法
System.out.println("\n=== 8. 调用方法 ===");
ReflectionUtils.invokeMethod(user3, "sayHello", "World");
// 9. 访问私有字段和修饰符检查
System.out.println("\n=== 9. 修饰符和注解检查 ===");
Field passwordField = User.class.getDeclaredField("password");
System.out.println("password字段的修饰符: " +
java.lang.reflect.Modifier.toString(passwordField.getModifiers()));
System.out.println("password字段是私有的: " +
java.lang.reflect.Modifier.isPrivate(passwordField.getModifiers()));
// 检查注解
Field emailField = User.class.getDeclaredField("email");
if (emailField.isAnnotationPresent(FieldInfo.class)) {
FieldInfo info = emailField.getAnnotation(FieldInfo.class);
System.out.println("email字段的注解值: " + info.value());
}
// 10. 通过反射获取所有带注解的字段
System.out.println("\n=== 10. 带注解的字段 ===");
List<Field> allFields = ReflectionUtils.getAllFields(User.class);
for (Field field : allFields) {
if (field.isAnnotationPresent(FieldInfo.class)) {
FieldInfo info = field.getAnnotation(FieldInfo.class);
System.out.println("字段 '" + field.getName() + "' 注解值: " + info.value());
}
}
// 11. 动态代理示例
System.out.println("\n=== 11. 动态代理示例 ===");
UserService service = new UserService();
UserService proxy = (UserService) java.lang.reflect.Proxy.newProxyInstance(
UserService.class.getClassLoader(),
new Class<?>[]{UserService.class},
new LoggingHandler(service)
);
User result = proxy.getUser(1L);
System.out.println("代理返回结果: " + result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 用户服务接口（用于动态代理演示）
*/
interface UserService {
User getUser(Long id);
}
/**
* 用户服务实现
*/
class UserServiceImpl implements UserService {
@Override
public User getUser(Long id) {
User user = new User();
user.setId(id);
user.setUsername("user" + id);
user.setEmail("user" + id + "@example.com");
return user;
}
}
/**
* 日志记录处理器（动态代理）
*/
class LoggingHandler implements java.lang.reflect.InvocationHandler {
private final Object target;
public LoggingHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, java.lang.reflect.Method method, Object[] args)
throws Throwable {
System.out.println("调用方法: " + method.getName() + " 参数: " +
java.util.Arrays.toString(args));
long startTime = System.currentTimeMillis();
Object result = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println("方法执行时间: " + (endTime - startTime) + "ms");
System.out.println("返回结果: " + result);
return result;
}
}
运行结果示例
=== 1. 获取Class对象的三种方式 ===
方式1: com.example.reflection.User
方式2: com.example.reflection.User
方式3: com.example.reflection.User
三种方式获取的是同一个Class对象: true
=== 2. 类信息 ===
===== 类信息 =====
类名: com.example.reflection.User
简单类名: User
包名: com.example.reflection
修饰符: public
父类: java.lang.Object
接口:
- java.io.Serializable
=== 3. 字段信息 ===
===== 字段信息 =====
字段名: id
类型: java.lang.Long
修饰符: private
注解: 用户ID
---
字段名: username
类型: java.lang.String
修饰符: private
注解: 用户名
---
// ... 更多输出
=== 6. 动态创建对象 ===
无参构造创建: User{id=null, username='null', password='null', email='null', createTime=null}
有参构造创建: User{id=1, username='john', password='123456', email='null', createTime=null}
// ... 等等实际应用场景
package com.example.reflection;
import java.util.HashMap;
import java.util.Map;
/**
* 反射的实际应用场景示例
*/
public class ReflectionApplication {
/**
* 场景1：将对象转换为Map
*/
public static Map<String, Object> objectToMap(Object obj) throws Exception {
Map<String, Object> map = new HashMap<>();
Class<?> clazz = obj.getClass();
// 获取所有字段
java.lang.reflect.Field[] fields = clazz.getDeclaredFields();
for (java.lang.reflect.Field field : fields) {
field.setAccessible(true);
map.put(field.getName(), field.get(obj));
}
return map;
}
/**
* 场景2：Map转换为对象
*/
public static <T> T mapToObject(Map<String, Object> map, Class<T> clazz) throws Exception {
T obj = clazz.newInstance();
for (Map.Entry<String, Object> entry : map.entrySet()) {
try {
java.lang.reflect.Field field = clazz.getDeclaredField(entry.getKey());
field.setAccessible(true);
field.set(obj, entry.getValue());
} catch (NoSuchFieldException e) {
// 忽略不存在的字段
}
}
return obj;
}
/**
* 场景3：简单的ORM框架模拟
*/
public static class SimpleORM {
public String insert(Object obj) {
Class<?> clazz = obj.getClass();
StringBuilder sql = new StringBuilder();
sql.append("INSERT INTO ").append(clazz.getSimpleName().toLowerCase()).append(" (");
java.lang.reflect.Field[] fields = clazz.getDeclaredFields();
// 拼接表名和字段
for (int i = 0; i < fields.length; i++) {
if (i > 0) sql.append(", ");
sql.append(fields[i].getName());
}
sql.append(") VALUES (");
for (int i = 0; i < fields.length; i++) {
if (i > 0) sql.append(", ");
sql.append("?");
}
sql.append(")");
return sql.toString();
}
}
public static void main(String[] args) {
try {
User user = new User();
user.setId(1L);
user.setUsername("test");
user.setPassword("123");
user.setEmail("test@example.com");
// 对象转Map
Map<String, Object> map = objectToMap(user);
System.out.println("对象转Map: " + map);
// Map转对象
User sameUser = mapToObject(map, User.class);
System.out.println("Map转对象: " + sameUser);
// 简单的ORM
SimpleORM orm = new SimpleORM();
System.out.println("SQL语句: " + orm.insert(user));
} catch (Exception e) {
e.printStackTrace();
}
}
}
这个案例涵盖了Java反射的核心知识点：
- 获取Class对象的三种方式
- 获取类的完整信息（类、字段、构造方法、方法）
- 动态创建对象
- 动态访问私有字段和方法
- 注解信息获取
- 动态代理实现
- 实际应用场景（对象转换、ORM模拟）
这些功能在框架开发、序列化、动态代理、依赖注入等领域都有广泛应用。
