常用的反射工具类ReflectionExtUtil.util
package com.gbcom.system.utils;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.log4j.Logger;
/**
* 反射工具栏
*
* @author syz
* @date 2014-5-8
* @version v1.0.0
* @see com.gbcom.dp.reflection.ReflectionExtUtil
*/
public class ReflectionExtUtil {
private static final Logger LOG = Logger.getLogger(ReflectionExtUtil.class);
/**
* 新建实例,要么不写构造函数,否则必须有一个默认构造函数
*
* @param className
* 类名
* @param args
* 构造函数的参数
* @return 新建的实例
* @throws Exception
* Exception
*/
public static Object newInstance(String className, Object[] args)
throws Exception {
Class newoneClass = Class.forName(className);
if (args == null) {
return newoneClass.newInstance();
}
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Constructor cons = newoneClass.getConstructor(argsClass);
return cons.newInstance(args);
}
/**
* 是不是某个类的实例
*
* @param obj
* 实例
* @param cls
* 类
* @return 如果 obj 是此类的实例,则返回 true
*/
public static boolean isInstance(Object obj, Class cls) {
return cls.isInstance(obj);
}
/**
* 循环向上转型, 获取对象的 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) {
LOG.error("error",e);
} catch (IllegalAccessException e) {
LOG.error("error",e);
} catch (InvocationTargetException e) {
LOG.error("error",e);
}
return null;
}
private static Field[] arryConcat(Field[] a, Field[] b) {
Field[] c = new Field[a.length + b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
return c;
}
private static Method[] arryConcat(Method[] a, Method[] b) {
Method[] c = new Method[a.length + b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
return c;
}
/**
* 获取对象的所有属性,包括父类
*
* @param object
* Object
* @return Field []
*/
public static Field[] getDeclaredFields(Object object) {
Class<?> clazz = object.getClass();
Field[] total = new Field[0];
for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
total = (Field[]) arryConcat(total, clazz.getDeclaredFields());
}
return total;
}
/**
* 获取对象的所有属性,包括父类
*
* @param clazz
* Class<?>
* @return Field []
*/
public static Field[] getDeclaredFields(Class<?> clazz) {
Field[] total = new Field[0];
for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
total = (Field[]) arryConcat(total, clazz.getDeclaredFields());
}
return total;
}
/**
* 获取对象的所有方法
*
* @param object
* Object
* @return Method []
*/
public static Method[] getDeclaredMethods(Object object) {
Class<?> clazz = object.getClass();
Method[] total = new Method[0];
for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
total = (Method[]) arryConcat(total, clazz.getDeclaredMethods());
}
return total;
}
/**
* 循环向上转型, 获取对象的 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) {
}
}
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) {
LOG.error("error",e);
} catch (IllegalAccessException e) {
LOG.error("error",e);
}
}
/**
* 直接读取对象的属性值, 忽略 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) {
LOG.error("error",e);
}
return null;
}
/**
* 设置属性值
*
* @param list
* ArrayList
* @param cla
* Class
* @return ArrayList
*/
@SuppressWarnings("unchecked")
public static ArrayList array2bean(ArrayList list, Class cla) {
ArrayList result = new ArrayList();
int filedLen = cla.getDeclaredFields().length;
System.out.println(":" + cla.getDeclaredFields().length);
for (int i = 0; i < list.size(); i++) {
Object[] o = (Object[]) list.get(i);
int length = filedLen < o.length ? filedLen : o.length;
try {
result.add(cla.newInstance());
for (int j = 0; j < length; j++) {
Method m = null;
String mName = cla.getDeclaredFields()[j].getName();
mName = mName.substring(0, 1).toUpperCase()
+ mName.substring(1);
mName = "set" + mName;
m = cla.getMethod(mName, new Class[] { String.class });
// 调用设置的方法,给属性赋值
m.invoke(result.get(i), new Object[] { o[j] == null ? ""
: o[j].toString() });
}
} catch (Exception e) {
LOG.error("error",e);
}
}
return result;
}
/**
*
* @param cla
* String
* @param attri
* Class
* @return Class
*/
public static Class getAttriTypeByName(Class cla, String attri) {
Field[] fds = getDeclaredFields(cla);
for (Field field : fds) {
if (field.getName().equals(attri)) {
return field.getType();
}
}
return String.class;
}
/**
* 获取对象的所有属性的 valueMap
*
* @param obj
* Object
* @return Map<String, Object>
* @throws SecurityException
* SecurityException
* @throws NoSuchMethodException
* NoSuchMethodException
* @throws IllegalArgumentException
* IllegalArgumentException
* @throws IllegalAccessException
* IllegalAccessException
* @throws InvocationTargetException
* InvocationTargetException
*/
public static Map<String, Object> getAttrsValueMap(Object obj)
throws SecurityException, NoSuchMethodException,
IllegalArgumentException, IllegalAccessException,
InvocationTargetException {
Map<String, Object> valueMap = new HashMap<String, Object>();
Class cla = obj.getClass();
Field[] fds = getDeclaredFields(obj);
Field field = null;
String fieldName = null;
String methodName = null;
Method method = null;
Object returnValue = null;
for (int i = 0; i < fds.length; i++) {
field = fds[i];
fieldName = field.getName();
methodName = "get" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
method = getDeclaredMethod(obj, methodName, null);
if (method == null) {
methodName = "is" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
method = getDeclaredMethod(obj, methodName, null);
}
if (method == null) {
System.out
.println("NullPoint exception , of reflection methodName="
+ methodName);
continue;
}
returnValue = method.invoke(obj, null);// 调用方法,相当于执行get方法得到的结果,这里返回的是一个对象
valueMap.put(fieldName, returnValue == null ? "" : returnValue);
}
return valueMap;
}
/**
* 根据MAP 设置对象的所有属性,
*
* @param obj
* Object
* @param valueMap
* Map<String, Object>
* @throws NoSuchMethodException
* NoSuchMethodException
* @throws SecurityException
* SecurityException
* @throws InvocationTargetException
* InvocationTargetException
* @throws IllegalAccessException
* IllegalAccessException
* @throws IllegalArgumentException
* IllegalArgumentException
*/
public static void setAttrsValueMap(Object obj, Map<String, Object> valueMap)
throws SecurityException, NoSuchMethodException,
IllegalArgumentException, IllegalAccessException,
InvocationTargetException {
Class cla = obj.getClass();
String fieldName = null;
String methodName = null;
Method method = null;
for (Entry<String, Object> entry : valueMap.entrySet()) {
// 预判断
if (entry.getValue() == null
|| String.valueOf(entry.getValue()).startsWith("noSuch")) {
continue;
}
fieldName = entry.getKey();
if (fieldName.equals("staticChannel")) {
System.out.println("xxx");
}
methodName = "set" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
Class type = entry.getValue().getClass();
if (type == Integer.class) {
type = int.class;
} else if (type == Boolean.class) {
type = boolean.class;
}
// Object varObj = convertClxValue(type, entry.getValue());
method = getDeclaredMethod(obj, methodName, type);
// if(method == null){
// type = int.class;
// method = getDeclaredMethod(obj,methodName, type);
// }
if (method == null) {
System.out
.println("NullPoint exception , of reflection methodName="
+ methodName);
continue;
}
method.invoke(obj, entry.getValue());// 调用方法,set操作注意
}
}
private static Object convertClxValue(Object value) {
if (value instanceof String) {
return String.valueOf(value);
}
return null;
}
}