Java反射案例

本文目录导读：

1. 基础实体类
2. 自定义注解
3. 反射工具类
4. 反射示例演示类
5. 运行结果示例
6. 实际应用场景

我将为您展示一个完整的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反射的核心知识点：

1. 获取Class对象的三种方式
2. 获取类的完整信息（类、字段、构造方法、方法）
3. 动态创建对象
4. 动态访问私有字段和方法
5. 注解信息获取
6. 动态代理实现
7. 实际应用场景（对象转换、ORM模拟）

这些功能在框架开发、序列化、动态代理、依赖注入等领域都有广泛应用。