【一个用于反射的工具类，提供了获取对象属性值、设置对象属性值、调用对象方法、过滤集合元素、获取类的构造器、获取类的方法、获取类的属性等常用反射操作的方法】

1、创建实体类

public class UserISI {
    private int userId;
    private String username;
    private Integer age;

    public UserISI(int userId, String username, int age) {
        this.userId = userId;
        this.username = username;
        this.age = age;
    }

    public UserISI(String username, int age) {
        this.username = username;
        this.age = age;
    }


    public UserISI() {
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "UserISI{" +
                "userId=" + userId +
                ", username='" + username + '\'' +
                ", age=" + age +
                '}';
    }

    public String toStringUsernameAndAge() {
        return "UserISI{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

2、MyReflectionUtil是一个用于反射的工具类，提供了获取对象属性值、设置对象属性值、调用对象方法、过滤集合元素、获取类的构造器、获取类的方法、获取类的属性等常用反射操作的方法。

package com.lfsun.common.util;

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * MyReflectionUtil是一个用于反射的工具类，提供了获取对象属性值、设置对象属性值、调用对象方法、过滤集合元素、获取类的构造器、获取类的方法、获取类的属性等常用反射操作的方法。
 *
 * @author Administrator
 */
public class MyReflectionUtil {

    /**
     * 获取对象指定属性的值
     *
     * @param object    目标对象
     * @param fieldName 属性名
     * @return 对象指定属性的值
     */
    public static Object getFieldValue(Object object, String fieldName) {
        Class<?> clazz = object.getClass();
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(object);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 设置对象指定属性的值
     *
     * @param object    目标对象
     * @param fieldName 属性名
     * @param value     属性值
     */
    public static void setFieldValue(Object object, String fieldName, Object value) {
        Class<?> clazz = object.getClass();
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(object, value);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 调用对象的指定方法
     *
     * @param object     目标对象
     * @param methodName 方法名
     * @param args       方法参数列表
     * @return 方法调用的返回值
     */
    public static Object invokeMethod(Object object, String methodName, Object... args) {
        Class<?>[] parameterTypes = new Class<?>[args.length];
        for (int i = 0; i < args.length; i++) {
            parameterTypes[i] = args[i].getClass();
        }

        Class<?> clazz = object.getClass();
        try {
            Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return method.invoke(object, args);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 过滤集合中满足条件的元素
     *
     * @param list      待过滤的集合
     * @param predicate 过滤条件
     * @param        集合元素类型
     * @return 满足条件的元素组成的集合
     */
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        return list.stream().filter(predicate).collect(Collectors.toList());
    }

    /**
     * 获取类的所有构造器，包括父类的构造器
     *
     * @param clazz 目标类
     * @return 类的所有构造器
     */
    public static List<Constructor<?>> getAllConstructors(Class<?> clazz) {
        List<Constructor<?>> constructors = new ArrayList<>();
        while (clazz != null) {
            constructors.addAll(Arrays.asList(clazz.getDeclaredConstructors()));
            clazz = clazz.getSuperclass();
        }
        return constructors;
    }

    public static List<Constructor<?>> getAllConstructorsNoPrivate(Class<?> clazz) {
        return Arrays.asList(clazz.getConstructors())
                .stream()
                .filter(constructor -> Modifier.isPublic(constructor.getModifiers()))
                .collect(Collectors.toList());
    }


    /**
     * 获取类的所有方法，包括父类的方法
     *
     * @param clazz 目标类
     * @return 类的所有方法
     */
    public static List<Method> getAllMethods(Class<?> clazz) {
        List<Method> methods = new ArrayList<>();
        while (clazz != null) {
            methods.addAll(Arrays.asList(clazz.getDeclaredMethods()));
            clazz = clazz.getSuperclass();
        }
        return methods;
    }

    /**
     * 获取类的所有属性，包括父类的属性
     *
     * @param clazz 目标类
     * @return 类的所有属性
     */
    public static List<Field> getAllFields(Class<?> clazz) {
        List<Field> fields = new ArrayList<>();
        while (clazz != null) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            clazz = clazz.getSuperclass();
        }
        return fields;
    }

    /**
     * 使用指定的构造器创建对象
     *
     * @param constructor 构造器
     * @param args        构造器参数列表
     * @param          对象类型
     * @return 创建的对象
     */
    public static <T> T createInstance(Constructor<T> constructor, Object... args) {
        try {
            constructor.setAccessible(true);
            return constructor.newInstance(args);
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取类的指定构造器
     *
     * @param clazz          目标类
     * @param parameterTypes 构造器参数类型列表
     * @param             对象类型
     * @return 指定的构造器
     */
    public static <T> Constructor<T> getConstructor(Class<T> clazz, Class<?>... parameterTypes) {
        try {
            return clazz.getDeclaredConstructor(parameterTypes);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }


}

3、测试类

package com.lfsun.common.util;

import com.lfsun.common.entity.UserISI;
import org.junit.Assert;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class MyReflectionUtilTest {

    @Test
    public void testGetAndSetFieldValue() {
        // 测试获取对象属性值和设置对象属性值
        UserISI UserISI = new UserISI("lfsun", 20);
        String username = (String) MyReflectionUtil.getFieldValue(UserISI, "username");
        Assert.assertEquals("lfsun", username);

        MyReflectionUtil.setFieldValue(UserISI, "username", "lfsun666");
        Assert.assertEquals("lfsun666", UserISI.getUsername());
    }

    @Test
    public void testInvokeMethod() {
        // 测试调用对象方法
        UserISI UserISI = new UserISI("lfsun", 20);
        String result = (String) MyReflectionUtil.invokeMethod(UserISI, "toStringUsernameAndAge");
        Assert.assertEquals("UserISI{username='lfsun', age=20}", result);
    }

    @Test
    public void testFilter() {
        // 测试过滤集合
        List<UserISI> UserISIList = new ArrayList<>();
        UserISIList.add(new UserISI("lfsun", 20));
        UserISIList.add(new UserISI("lfsun666", 18));
        UserISIList.add(new UserISI("冷风扇", 25));
        Predicate<UserISI> predicate = UserISI -> UserISI.getAge() >= 25;
        List<UserISI> filteredList = MyReflectionUtil.filter(UserISIList, predicate);
        System.out.println(filteredList);
    }

    @Test
    public void testGetAllConstructors() {
        // 测试获取类的所有构造函数
        List<Constructor<?>> constructors = MyReflectionUtil.getAllConstructors(UserISI.class);
        System.out.println(constructors);
    }

    @Test
    public void testGetAllConstructorsNoPrivate() {
        // 测试获取类的所有构造函数
        List<Constructor<?>> constructors = MyReflectionUtil.getAllConstructorsNoPrivate(UserISI.class);
        System.out.println(constructors);
    }

    @Test
    public void testGetAllMethods() {
        // 测试获取类的所有方法
        List<Method> methods = MyReflectionUtil.getAllMethods(UserISI.class);
        System.out.println(methods);
    }

    @Test
    public void testGetAllFields() {
        // 测试获取类的所有属性
        List<Field> fields = MyReflectionUtil.getAllFields(UserISI.class);
        System.out.println(fields);
    }

    @Test
    public void testCreateInstance() {
        // 测试创建类的实例
        Constructor<UserISI> constructor = MyReflectionUtil.getConstructor(UserISI.class, String.class, int.class);
        assert constructor != null;
        UserISI userISI = MyReflectionUtil.createInstance(constructor, "lfsun", 20);
        assert userISI != null;
        System.out.println(userISI);
    }

    @Test
    public void testGetConstructor() {
        // 测试获取类的构造函数
        Constructor<UserISI> constructor = MyReflectionUtil.getConstructor(UserISI.class, String.class, int.class);
        System.out.println(constructor);
    }

}