反射组件使用方法与封装实践的长尾关键词标题：反射组件详细使用方法与高效封装实践解析

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectionUtils {
    // 1. 实例化工具方法
    public static <T> T newInstance(Class<T> clazz, Object... args) {
        try {
            Class<?>[] argTypes = Arrays.stream(args)
                    .map(Object::getClass)
                    .toArray(Class<?>[]::new);
            Constructor<T> constructor = clazz.getDeclaredConstructor(argTypes);
            constructor.setAccessible(true);
            return constructor.newInstance(args);
        } catch (NoSuchMethodException | InstantiationException |
                IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException("实例化对象失败", e);
        }
    }

    // 2. 方法调用工具方法
    public static Object invokeMethod(Object target, String methodName, Object... args) {
        try {
            Class<?>[] argTypes = Arrays.stream(args)
                    .map(Object::getClass)
                    .toArray(Class<?>[]::new);
            Method method = target.getClass().getDeclaredMethod(methodName, argTypes);
            method.setAccessible(true);
            return method.invoke(target, args);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException("方法调用失败", e);
        }
    }

    // 3. 字段操作工具方法
    public static void setFieldValue(Object target, String fieldName, Object value) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(target, value);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException("字段设置失败", e);
        }
    }

    public static Object getFieldValue(Object target, String fieldName) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(target);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException("字段获取失败", e);
        }
    }

    // 注解解析工具方法
    public static <A extends java.lang.annotation.Annotation> A getAnnotation(Class<?> clazz, Class<A> annotationClass) {
        return clazz.getAnnotation(annotationClass);
    }
}

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class JsonDeserializer {
    public static <T> T fromJson(String json, Class<T> clazz) {
        // 简化示例：实际需使用JSON解析库（如Jackson/Gson）
        Map<String, String> jsonMap = parseJsonToMap(json);
        try {
            T instance = clazz.getDeclaredConstructor().newInstance();
            for (Field field : clazz.getDeclaredFields()) {
                field.setAccessible(true);
                String fieldName = field.getName();
                if (jsonMap.containsKey(fieldName)) {
                    String value = jsonMap.get(fieldName);
                    // 类型转换简化处理
                    if (field.getType() == String.class) {
                        field.set(instance, value);
                    } else if (field.getType() == int.class || field.getType() == Integer.class) {
                        field.set(instance, Integer.parseInt(value));
                    } // 其他类型转换...
                }
            }
            return instance;
        } catch (Exception e) {
            throw new RuntimeException("JSON反序列化失败", e);
        }
    }

    private static Map<String, String> parseJsonToMap(String json) {
        // 简化实现，实际应使用专业JSON解析库
        Map<String, String> map = new HashMap<>();
        // 移除JSON字符串中的花括号
        String content = json.substring(1, json.length() - 1);
        String[] keyValuePairs = content.split(",");
        for (String pair : keyValuePairs) {
            String[] parts = pair.split(":");
            if (parts.length == 2) {
                String key = parts[0].trim().replaceAll("\"", "");
                String value = parts[1].trim().replaceAll("\"", "");
                map.put(key, value);
            }
        }
        return map;
    }
}

public class User {
    private String name;
    private int age;
    // 省略构造方法和Getter/Setter
}

// 测试代码
public static void main(String[] args) {
    // 1. 使用工具类实例化对象
    User user = ReflectionUtils.newInstance(User.class, "张三", 25);

    // 2. 动态调用方法
    ReflectionUtils.invokeMethod(user, "setName", "李四");
    String name = (String) ReflectionUtils.invokeMethod(user, "getName");

    // 3. 字段反射操作
    ReflectionUtils.setFieldValue(user, "age", 30);
    int age = (int) ReflectionUtils.getFieldValue(user, "age");

    // JSON反序列化
    String json = "{\"name\":\"王五\",\"age\":35}";
    User userFromJson = JsonDeserializer.fromJson(json, User.class);
}