反射工具类(调用父类的方法和字段)

最新推荐文章于 2024-07-30 15:32:58 发布

edgewalk

最新推荐文章于 2024-07-30 15:32:58 发布

阅读量5.5k

点赞数 1

CC 4.0 BY-SA版权

分类专栏：反射文章标签：反射权限 java

本文链接：https://blog.youkuaiyun.com/weixin_38756990/article/details/72871801

反射专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了一个用于操作Java类、方法及字段的工具类，利用Java反射API实现了无视访问权限限制来调用方法和修改字段的功能，并提供了具体示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

使用这个工具类,可以完成父类,基类,方法,字段,无论什么权限都可以调用.

package com.reflect;
/**
 * 基类
 * @author jianghui
 */
public class GrandParent {
    public String publicField = "1";

    String defaultField = "2";

    protected String protectedField = "3";

    private String privateField = "4";

    public void publicMethod() {
        System.out.println("publicMethod...");
    }

    void defaultMethod() {
        System.out.println("defaultMethod...");
    }

    protected void protectedMethod() {
        System.out.println("protectedMethod...");
    }

    private void privateMethod() {
        System.out.println("privateMethod...");
    }

}

package com.reflect;
/**
 * 父类
 * @author jianghui
 */
public class Parent extends GrandParent {

}

package com.reflect;
/**
 * 子类
 * @author jianghui
 */
public class Son extends Parent {

}

package com.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 方法类
 * 
 * @author jianghui
 */
public class ReflectionUtils {

    /**
     * 循环向上转型, 获取对象的 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;
    }
}

package com.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.Test;

/**
 * 测试类 
 * @author jianghui
 */
public class ReflectionUtilsTest {  

   /** 
    * 测试获取父类的各个方法对象 
    */  
   @Test  
   public void testGetDeclaredMethod() {  

       Object obj = new Son() ;  

       //获取公共方法名  
       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 Son() ;  

       //调用父类的公共方法  
       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 Son() ;  

       //获取公共属性名  
       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 Son() ;  

       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 Son() ;  

       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"));  
   }  

}