com.base4j.util.ReflectionUtils Maven / Gradle / Ivy
The newest version!
package com.base4j.util;
import org.apache.commons.lang3.StringUtils;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;
public class ReflectionUtils {
/**
* 获取类方法的相关信息
*
* @param target 目标类
* @param propertyName 参数名称
* @return Object 对象
*/
public static Object invokeGetterMethod(Object target, String propertyName) {
String getterMethodName = "get" + StringUtils.capitalize(propertyName);
return invokeMethod(target, getterMethodName, new Class[]{}, new Object[]{});
}
public static void invokeSetterMethod(Object target, String propertyName, Object value) {
invokeSetterMethod(target, propertyName, value, null);
}
public static void invokeSetterMethod(Object target, String propertyName, Object value, Class propertyType) {
Class type = propertyType != null ? propertyType : value.getClass();
String setterMethodName = "set" + StringUtils.capitalize(propertyName);
invokeMethod(target, setterMethodName, new Class[]{type}, new Object[]{value});
}
/**
* 直接调用对象方法, 而忽略修饰符(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);
try {
if (null != method) {
// 抑制Java对方法进行检查,主要是针对私有方法而言
method.setAccessible(true);
// 调用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;
}
/**
* 循环向上转型, 获取对象的 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;
}
/**
* 循环向上转型, 获取对象的 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;
}
/**
* 循环向上转型, 获取对象的 DeclaredField
*
* @param object : 子类对象
* @return 父类中的属性对象
*/
public static Field[] getAllDeclaredFields(Object object) {
Field[] fields = null;
List list = new ArrayList();
Class clazz = object.getClass();
for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
try {
fields = clazz.getDeclaredFields();
if (fields != null && fields.length > 0) {
for (Field fieldOne : fields) {
list.add(fieldOne);
}
}
} catch (Exception e) {
// 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
// 如果这里的异常打印或者往外抛，则就不会执行clazz =
// clazz.getSuperclass(),最后就不会进入到父类中了
}
}
fields = list.toArray(fields);
return fields;
}
/**
* 直接设置对象属性值, 忽略 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;
}
/**
* 获得父类信息
*
* @param clazz
* @return Class
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(final Class clazz) {
return getSuperClassGenricType(clazz, 0);
}
/**
* 获得父类信息
*
* @param clazz
* @param index
* @return Class
*/
public static Class getSuperClassGenricType(final Class clazz, final int index) {
Type genType = clazz.getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
//logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
// logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
// + params.length);
return Object.class;
}
if (!(params[index] instanceof Class)) {
//logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class) params[index];
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy