devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java通过反射获取类名、属性名称_object.getclass().getdeclaredmethod(methodname);

作者：不正经 | 2024-03-22 15:41:55

赞

踩

object.getclass().getdeclaredmethod(methodname);

getMethods()：获取当前类及所有继承的、父类的public修饰的方法，仅包括public。
getDeclaredMethods()：获取当前类的所有方法，包括public/private/protected/default修饰的方法。
getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。 
getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。

getAnnotation()方法可用于获取指定类型的注释，若不存在则返回null。

  1. Field[] fields = tClass.getDeclaredFields();
  2. List<String> headers = new ArrayList<>();
  3. for (Field field: fields) {
  4.     ExcelProperty property = field.getAnnotation(ExcelProperty.class);
  5.     if (property != null) {
  6.         String[] s = property.value();
  7.         if (s.length > 0) {
  8.             headers.add(s[0]);
  9.         }
  10.     }
  11. }
  12. String[] strings = new String[headers.size()];
  13. headers.toArray(strings);
  14. return strings;
  15. }

定义反射工具类

  1. import java.lang.reflect.Field;
  2. import java.lang.reflect.InvocationTargetException;
  3. import java.lang.reflect.Method;
  4.  
  5. /**
  6.  * 方法类
  7.  */
  8. public class ReflectionUtils {
  9.  
  10.     /**
  11.      * 循环向上转型
  12.      * @param object    子类对象
  13.      * @param methodName    父类中的方法名
  14.      * @param parameterTypes    父类中的方法参数类型
  15.      * @return  父类中的方法对象
  16.      */
  17.     public static Method getDeclaredMethod(Object object, String methodName, Class<?>... parameterTypes){
  18.         Method method = null;
  19.         for(Class<?> clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()){
  20.             try {
  21.                 method = clazz.getDeclaredMethod(methodName, parameterTypes);
  22.                 return method;
  23.             } catch (NoSuchMethodException e) {
  24.                 //不需要处理
  25.                 //不断向父类查询是否有某个方法
  26.             }
  27.         }
  28.         return null;
  29.     }
  30.  
  31.     /**
  32.      * 直接调用对象方法，而忽略修饰符(private, protected, default)
  33.      * @param object    子类对象
  34.      * @param methodName    父类的方法名
  35.      * @param parameterTypes    父类的方法参数类型
  36.      * @param parameters        父类的方法参数
  37.      * @return      父类中方法的执行结果
  38.      */
  39.     public static Object invokeMethod(Object object, String methodName, Class<?>[] parameterTypes,
  40.                                       Object[] parameters){
  41.         //根据对象、方法名和对应的方法参数，通过取Method对象
  42.         Method method = getDeclaredMethod(object, methodName, parameterTypes);
  43.         //控制Java对方法进行检查，主要针对私有方法而言
  44.         method.setAccessible(true);
  45.         try {
  46.             if(null != method) {
  47.                 //调用object的method所代表的方法，其方法的参数是parameters
  48.                 return method.invoke(object, parameters);
  49.             }
  50.         } catch (IllegalAccessException e) {
  51.             e.printStackTrace();
  52.         } catch (InvocationTargetException e) {
  53.             e.printStackTrace();
  54.         }
  55.  
  56.         return null;
  57.     }
  58.  
  59.     /**
  60.      * 循环向上转型, 获
  61.      * @param object : 子类对象
  62.      * @param fieldName : 父类中
  63.      * @return 父类中
  64.      * */
  65.     public static Field getDeclaredField(Object object, String fieldName){
  66.         Field field = null;
  67.         Class<?> clazz = object.getClass();
  68.         for(;clazz != Object.class; clazz = clazz.getSuperclass()){
  69.             try {
  70.                 field = clazz.getDeclaredField(fieldName);
  71.                 return field;
  72.             } catch (NoSuchFieldException e) {
  73.                 //不需要处理
  74.                 //不断向父类查询是否有某个字段
  75.             }
  76.         }
  77.         return null;
  78.     }
  79.  
  80.     /**
  81.      * 直接设置对象的属性值，忽略private/protected修饰符
  82.      * @param object    子类对象
  83.      * @param fieldName 父类中的字段名
  84.      * @param value     将要设置的值
  85.      */
  86.     public static void setFieldValue(Object object, String fieldName, Object value){
  87.         //根据对象和属性名通过取Field对象
  88.         Field field = getDeclaredField(object, fieldName);
  89.         //控制Java对其的检查
  90.         field.setAccessible(true);
  91.         //将object中field所代表的的值设置为value
  92.         try {
  93.             field.set(object, value);
  94.         } catch (IllegalAccessException e) {
  95.             e.printStackTrace();
  96.         }
  97.     }
  98.  
  99.     /**
  100.      * 直接读的属性值, 忽略 private/protected 修饰符, 也
  101.      * @param object : 子类对象
  102.      * @param fieldName : 父类中
  103.      * @return : 父类中     */
  104.     public static Object getFieldValue(Object object, String fieldName){
  105.         //根据对象和属性名通过取Field对象
  106.         Field field = getDeclaredField(object, fieldName);
  107.         field.setAccessible(true);
  108.         try {
  109.             return field.get(object);
  110.         } catch (IllegalAccessException e) {
  111.             e.printStackTrace();
  112.         }
  113.         return  null;
  114.     }
  115. }

定义父类的属性和方法

  1. //父类
  2. public class Parent {
  3.     public String publicField = "1";
  4.     String defaultField = "2";
  5.     protected String protectedField = "3";
  6.     private String privateField = "4";
  7.  
  8.     public void publicMethod(String name) {
  9.         System.out.println("publicMethod...");
  10.     }
  11.  
  12.     void defaultMethod() {
  13.         System.out.println("defaultMethod...");
  14.     }
  15.  
  16.     protected void protectedMethod() {
  17.         System.out.println("protectedMethod...");
  18.     }
  19.  
  20.     private void privateMethod() {
  21.         System.out.println("privateMethod...");
  22.     }
  23. }
  24. //子类
  25. public class Son extends Parent{
  26.     
  27. }

测试反射

  1. import org.junit.Test;
  2.  
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Method;
  5.  
  6. public class ReflectionUtilsTest {
  7.     /**
  8.      * 测试获取父类的方法实例
  9.      */
  10.     @Test
  11.     public void testGetDeclaredMethod(){
  12.         Object obj = new Son();
  13.         //public方法
  14.         Method publicMethod = ReflectionUtils.getDeclaredMethod(obj, "publicMethod", String.class);
  15.         System.out.println(publicMethod.getName());
  16.  
  17.         //default方法
  18.         Method defaultMethod = ReflectionUtils.getDeclaredMethod(obj, "defaultMethod") ;
  19.         System.out.println(defaultMethod.getName());
  20.  
  21.         //protected方法
  22.         Method protectedMethod = ReflectionUtils.getDeclaredMethod(obj, "protectedMethod") ;
  23.         System.out.println(protectedMethod.getName());
  24.  
  25.         //私有方法
  26.         Method privateMethod = ReflectionUtils.getDeclaredMethod(obj, "privateMethod") ;
  27.         System.out.println(privateMethod.getName());
  28.     }
  29.  
  30.     /**
  31.      * 调用父类的方法
  32.      */
  33.     @Test
  34.     public void testInvokeMethod(){
  35.         Object obj = new Son();
  36.         //调用
  37.         ReflectionUtils.invokeMethod(obj, "publicMethod", String.class, "2342");
  38.         //调用
  39.         ReflectionUtils.invokeMethod(obj, "defaultMethod", null , null) ;
  40.         //调用
  41.         ReflectionUtils.invokeMethod(obj, "protectedMethod", null , null) ;
  42.         //调用
  43.         ReflectionUtils.invokeMethod(obj, "privateMethod", null , null) ;
  44.     }
  45.  
  46.     /**
  47.      * 测试获父类的各个属性名
  48.      */
  49.     @Test
  50.     public void testGetDeclaredField() {
  51.  
  52.         Object obj = new Son() ;
  53.  
  54.         //获DeclaredField
  55.         Field publicField = ReflectionUtils.getDeclaredField(obj, "publicField") ;
  56.         System.out.println(publicField.getName());
  57.  
  58.         //获DeclaredField
  59.         Field defaultField = ReflectionUtils.getDeclaredField(obj, "defaultField") ;
  60.         System.out.println(defaultField.getName());
  61.  
  62.         //获DeclaredField
  63.         Field protectedField = ReflectionUtils.getDeclaredField(obj, "protectedField") ;
  64.         System.out.println(protectedField.getName());
  65.  
  66.         //获DeclaredField
  67.         Field privateField = ReflectionUtils.getDeclaredField(obj, "privateField") ;
  68.         System.out.println(privateField.getName());
  69.     }
  70.     
  71.     //设置属性值
  72.     @Test
  73.     public void testSetFieldValue() {
  74.  
  75.         Object obj = new Son() ;
  76.  
  77.         System.out.println("原来的各个属性的值: ");
  78.         System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
  79.         System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
  80.         System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
  81.         System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
  82.  
  83.         ReflectionUtils.setFieldValue(obj, "publicField", "a") ;
  84.         ReflectionUtils.setFieldValue(obj, "defaultField", "b") ;
  85.         ReflectionUtils.setFieldValue(obj, "protectedField", "c") ;
  86.         ReflectionUtils.setFieldValue(obj, "privateField", "d") ;
  87.  
  88.         System.out.println("***********************************************************");
  89.  
  90.         System.out.println("将属性值改变后的各个属性值: ");
  91.         System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
  92.         System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
  93.         System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
  94.         System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
  95.  
  96.     }
  97.     
  98.     /**
  99.     *  获取属性值
  100.     */
  101.     @Test
  102.     public void testGetFieldValue() {
  103.  
  104.         Object obj = new Son() ;
  105.  
  106.         System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
  107.         System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
  108.         System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
  109.         System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
  110.     }
  111.  
  112.  
  113. }

spring提供的ReflectionUtils

spring提供的ReflectionUtils可以简化项目中反射代码的复杂性。源码位置：org.springframework.util.ReflectionUtils
在项目中如果使用最原始的方法来开发反射的功能的话肯能会比较复杂，需要处理一大堆异常以及访问权限等问题

获取方法

Method method = ReflectUtil.getMethod(obj.getClass(), methodName);

obj 是bean对象，getMethod方法有多个重载，可以声明参数

执行方法

ReflectionUtils.invokeMethod(method, obj, args);

method方法实体，obj bean实体，args参数

mybatisplus提供的ReflectionKit

plus提供的ReflectionUtils可以简化项目中反射代码的复杂性。源码位置：com.baomidou.mybatisplus.toolkit.ReflectionKit

  1. C c = new C();
  2. c.setSex("女");
  3. c.setName("妹纸");
  4. c.setAge(18);
  5. Assertions.assertEquals(c.getSex(), ReflectionKit.getMethodValue(c.getClass(), c, "sex"));
  6. Assertions.assertEquals(c.getAge(), ReflectionKit.getMethodValue(c, "age"));
  7.  
  8. Map<String, Field> map = ReflectionKit.getFieldMap(c.class)
  9. for (String key: map.keySet()) {
  10.   ReflectionKit.getMethodValue(c, key);
  11. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/289124
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号