【Java工具类】反射工具类(支持操作父类的方法、属性值)

Love The Way You Lie 2022-11-17 05:10 237阅读 0赞

import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.*;
    public class ReflectionUtils { 
    
        /** * 获取父类和子类的所有对象 * * @param obj * @return */
        public static Map<String, Object> getAllFieldsToMap(Object obj) throws IllegalAccessException { 
            Map<String, Object> map = new LinkedHashMap<String, Object>();
    
            //获取当前类以及父类的所有字段
            Field[] fields = getAllFields(obj);
    
            if (fields == null) return map;
    
            for (Field field : fields) { 
                field.setAccessible(true);
                String fieldName = field.getName();
                Object value = field.get(obj);
                if (value == null) { 
                    value = "";
                }
                map.put(fieldName, value);
            }
    
            return map;
        }
    
        /** * 获取父类和子类的所有对象 * @param object * @return * [反射获取父类属性](https://www.jianshu.com/p/6fe3e0e185ac) */
        public static Field[] getAllFields(Object object){ 
            Class clazz = object.getClass();
            List<Field> fieldList = new LinkedList<>();
            while (clazz != null){ 
                fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
                clazz = clazz.getSuperclass();
            }
            Field[] fields = new Field[fieldList.size()];
            fieldList.toArray(fields);
            return fields;
        }
    
    
        /** * 循环向上转型, 获取对象的 DeclaredMethod * @param object : 子类对象 * @param methodName : 父类中的方法名 * @param parameterTypes : 父类中的方法参数类型 * @return 父类中的方法对象 */
    
        public static Method getDeclaredMethod(Object object, String methodName, Class<?> ... parameterTypes){ 
            Method method = null ;
    
            for(Class<?> clazz = object.getClass() ; clazz != Object.class ; clazz = clazz.getSuperclass()) { 
                try { 
                    method = clazz.getDeclaredMethod(methodName, parameterTypes) ;
                    return method ;
                } catch (Exception e) { 
                    //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
                    //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
    
                }
            }
    
            return null;
        }
    
        /** * 直接调用对象方法, 而忽略修饰符(private, protected, default) * @param object : 子类对象 * @param methodName : 父类中的方法名 * @param parameterTypes : 父类中的方法参数类型 * @param parameters : 父类中的方法参数 * @return 父类中方法的执行结果 */
    
        public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
                Object [] parameters) { 
            //根据 对象、方法名和对应的方法参数 通过反射 调用上面的方法获取 Method 对象
            Method method = getDeclaredMethod(object, methodName, parameterTypes) ;
    
            //抑制Java对方法进行检查,主要是针对私有方法而言
            method.setAccessible(true) ;
    
                try { 
                    if(null != method) { 
    
                        //调用object 的 method 所代表的方法，其方法的参数是 parameters
                        return method.invoke(object, parameters) ;
                    }
                } catch (IllegalArgumentException e) { 
                    e.printStackTrace();
                } catch (IllegalAccessException e) { 
                    e.printStackTrace();
                } catch (InvocationTargetException e) { 
                    e.printStackTrace();
                }
    
            return null;
        }
    
        /** * 循环向上转型, 获取对象的 DeclaredField * @param object : 子类对象 * @param fieldName : 父类中的属性名 * @return 父类中的属性对象 */
    
        public static Field getDeclaredField(Object object, String fieldName){ 
            Field field = null ;
    
            Class<?> clazz = object.getClass() ;
    
            for(; clazz != Object.class ; clazz = clazz.getSuperclass()) { 
                try { 
                    field = clazz.getDeclaredField(fieldName) ;
                    return field ;
                } catch (Exception e) { 
                    //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
                    //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
    
                }
            }
    
            return null;
        }
    
        /** * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter * @param object : 子类对象 * @param fieldName : 父类中的属性名 * @param value : 将要设置的值 */
    
        public static void setFieldValue(Object object, String fieldName, Object value){ 
    
            //根据 对象和属性名通过反射 调用上面的方法获取 Field对象
            Field field = getDeclaredField(object, fieldName) ;
    
            //抑制Java对其的检查
            field.setAccessible(true) ;
    
            try { 
                //将 object 中 field 所代表的值 设置为 value
                 field.set(object, value) ;
            } catch (IllegalArgumentException e) { 
                e.printStackTrace();
            } catch (IllegalAccessException e) { 
                e.printStackTrace();
            }
    
        }
    
        /** * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter * @param object : 子类对象 * @param fieldName : 父类中的属性名 * @return : 父类中的属性值 */
    
        public static Object getFieldValue(Object object, String fieldName){ 
    
            //根据 对象和属性名通过反射 调用上面的方法获取 Field对象
            Field field = getDeclaredField(object, fieldName) ;
    
            //抑制Java对其的检查
            field.setAccessible(true) ;
    
            try { 
                //获取 object 中 field 所代表的属性值
                return field.get(object) ;
    
            } catch(Exception e) { 
                e.printStackTrace() ;
            }
    
            return null;
        }
    }

测试类，测试对象自己定义即可

import org.junit.Test;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    /** * 测试类,用JUnit4 进行测试 * * @author syh */
    
    public class ReflectionUtilsTest { 
    
        /** * 测试获父类的各个方法对象 */
    
        @Test
        public void testGetDeclaredMethod() { 
    
            Object obj = new CommonReqParam();
    
           //获
            Method publicMethod = ReflectionUtils.getDeclaredMethod(obj, "publicMethod") ;
            System.out.println(publicMethod.getName());
    
            //获
            Method defaultMethod = ReflectionUtils.getDeclaredMethod(obj, "defaultMethod") ;
            System.out.println(defaultMethod.getName());
    
            //获
            Method protectedMethod = ReflectionUtils.getDeclaredMethod(obj, "protectedMethod") ;
            System.out.println(protectedMethod.getName());
    
            //获
            Method privateMethod = ReflectionUtils.getDeclaredMethod(obj, "privateMethod") ;
            System.out.println(privateMethod.getName());
        }
    
        /** * 测试调用 * @throws Exception */
    
        @Test
        public void testInvokeMethod() throws Exception { 
            Object obj = new CommonReqParam();
    
            //调用
            ReflectionUtils.invokeMethod(obj, "publicMethod", null , null) ;
    
            //调用
             ReflectionUtils.invokeMethod(obj, "defaultMethod", null , null) ;
    
            //调用
            ReflectionUtils.invokeMethod(obj, "protectedMethod", null , null) ;
    
            //调用
           ReflectionUtils.invokeMethod(obj, "privateMethod", null , null) ;
        }
    
        /** * 测试获父类的各个属性名 */
    
        @Test
        public void testGetDeclaredField() { 
    
            Object obj = new CommonReqParam();
    
            //获
            Field publicField = ReflectionUtils.getDeclaredField(obj, "publicField") ;
            System.out.println(publicField.getName());
    
            //获
            Field defaultField = ReflectionUtils.getDeclaredField(obj, "defaultField") ;
            System.out.println(defaultField.getName());
    
            //获
            Field protectedField = ReflectionUtils.getDeclaredField(obj, "protectedField") ;
            System.out.println(protectedField.getName());
    
            //获
             Field privateField = ReflectionUtils.getDeclaredField(obj, "privateField") ;
            System.out.println(privateField.getName());
    
        }
    
        @Test
        public void testSetFieldValue() { 
    
            Object obj = new CommonReqParam();
    
            System.out.println("原来的各个属性的值: ");
            System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
            System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
            System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
            System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
    
            ReflectionUtils.setFieldValue(obj, "publicField", "a");
            ReflectionUtils.setFieldValue(obj, "defaultField", "b");
            ReflectionUtils.setFieldValue(obj, "protectedField", "c");
            ReflectionUtils.setFieldValue(obj, "privateField", "d");
    
            System.out.println("***********************************************************");
    
            System.out.println("将属性值改变后的各个属性值: ");
            System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
            System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
            System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
            System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
    
        }
    
        @Test
        public void testGetFieldValue() { 
            Object obj = new CommonReqParam();
    
    
            System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
            System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
            System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
            System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
        }
    
    
        @Test
        public void testSuperField() { 
            Object obj = new CommonReqParam();
            ReflectionUtils.getAllFields(obj);
        }
    }