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

素颜马尾好姑娘i 2023-09-26 19:54 28阅读 0赞

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 <T>       集合元素类型
         * @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 <T>         对象类型
         * @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 <T>            对象类型
         * @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);
        }
    
    }