反射工具类

import java.lang.reflect.Field;  

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
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 父类中方法的执行结果
     * 调用示例  ReflectionUtils.invokeMethod(class,"方法名",null , null)
     */  

    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;
    }
}  
时间: 2024-10-16 22:32:53

反射工具类的相关文章

反射工具类——ReflectUtils

测试方法:根据已知的方法名,来反射调用方法 package com.redmoon.forum.job; import java.util.ArrayList; import java.util.List; import com.common.utils.ReflectUtils; public class Test { private String name; public String getName() { return name; } public void setName(String

Java 反射工具类

package com.su.dolphin.utils; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * * @className: ReflectionUti

Spring 反射工具类ReflectionUtils

public static final int PUBLIC = 0x00000001; public static final int PRIVATE = 0x00000002; public static final int PROTECTED = 0x00000004; public static final int STATIC = 0x00000008; public static final int FINAL = 0x00000010; public static final in

ReflectUtil反射工具类

原文:https://blog.csdn.net/u011704894/article/details/50548925 ReflectUtil: import java.lang.reflect.Field; import java.lang.reflect.Method; /** * Java反射工具类<br> * 提供以下几个功能:<br> * 1. 取最简类名<br> * 2. 动态赋值<br> * 3. 动态取值<br> * 4. 判断

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

使用这个工具类,可以完成父类,基类,方法,字段,无论什么权限都可以调用. package com.reflect; /** * 基类 * @author jianghui */ public class GrandParent { public String publicField = "1"; String defaultField = "2"; protected String protectedField = "3"; private St

Java 反射工具类封装

封装了常用的反射相关方法 public class ReflectUtil { /** * 通过类路径获取Class * * @author LHY <br> * Description <br> * LastModified 2014-5-9 Content <br> */ public static Class<?> getClass(String packagePath) throws ClassNotFoundException { return C

Spring的反射工具类 ReflectionUtils

/* * Copyright 2002-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://

Atitit apache 和guava的反射工具

apache1 Spring的反射工具类 ReflectionUtils1 Guava 反射工具2 apache  34             7,340 ConstructorUtils.java 34            16,263 FieldUtils.java 34             4,918 MemberUtils.java 34            14,175 MethodUtils.java 34            30,316 TypeUtils.java

《项目架构那点儿事》——工具类,你喜欢你就拿去

[前言]众所周知,各式各样的Util类为我们提供了便利,也同时减少了我们对底层硬编码的时间,包括对字符串的操作,文件操作,反射的操作,泛型的操作,以及熟知 的分页类,Json解析类.日期工具类等,这里把我开发的项目中用到过的工具类分享出来,都是经过多个项目的开发积累而锤炼出来的,提供给大家交流和学 习. [目录]            1.文件操作类 FileUtil            2.反射工具类 ReflectionUtil            3.泛型工具类 GenericsUti