java反射工具类

import java.lang.reflect.Field;import java.lang.reflect.Modifier;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.ArrayList;import java.util.Collection;import java.util.List;import org.apache.commons.beanutils.PropertyUtils;import org.apache.commons.lang.StringUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import com.ocj.pojo.ProductBean;/** * 反射的Utils函数集合. 提供访问私有变量,获取泛型类型Class,提取集合中元素的属性等Utils函数. *  * @author luochang */public class ReflectionUtils {private static Logger logger = LoggerFactory.getLogger(ReflectionUtils.class);private ReflectionUtils() {}/** * 直接读取对象属性值,无视private/protected修饰符,不经过getter函数. */public static Object getFieldValue(final Object object, final String fieldName) {Field field = getDeclaredField(object, fieldName);if (field == null)throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");makeAccessible(field);Object result = null;try {result = field.get(object);} catch (IllegalAccessException e) {logger.error("不可能抛出的异常{}", e.getMessage());}return result;}/** * 直接设置对象属性值,无视private/protected修饰符,不经过setter函数. */public static void setFieldValue(final Object object, final String fieldName, final Object value) {Field field = getDeclaredField(object, fieldName);if (field == null)throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");makeAccessible(field);try {field.set(object, value);} catch (IllegalAccessException e) {logger.error("不可能抛出的异常:{}", e.getMessage());}}/** * 循环向上转型,获取对象的DeclaredField. */protected static Field getDeclaredField(final Object object, final String fieldName) {//Assert.notNull(object, "object不能为空");return getDeclaredField(object.getClass(), fieldName);}/** * 循环向上转型,获取类的DeclaredField. */@SuppressWarnings("unchecked")protected static Field getDeclaredField(final Class clazz, final String fieldName) {//Assert.notNull(clazz, "clazz不能为空");//Assert.hasText(fieldName, "fieldName");for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {try {return superClass.getDeclaredField(fieldName);} catch (NoSuchFieldException e) {// Field不在当前类定义,继续向上转型}}return null;}/** * 循环向上转型,获取类的所有的DeclaredField,无视修饰符 */protected static List<String> getDeclaredField(final Class clazz) {List<String>fields=new ArrayList<String>();if (clazz!=Object.class) {Field [] arr =clazz.getDeclaredFields();if (arr!=null && arr.length>0) {for (int i = 0; i < arr.length; i++) {makeAccessible(arr[i]);fields.add(arr[i].getName());}}}return fields;}/** * 强制转换fileld可访问. */protected static void makeAccessible(final Field field) {if (!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())) {field.setAccessible(true);}}/** * 通过反射,获得定义Class时声明的父类的泛型参数的类型. 如public UserDao extends HibernateDao<User> *  * @param clazz *            The class to introspect * @return the first generic declaration, or Object.class if cannot be *         determined */@SuppressWarnings("unchecked")public static Class getSuperClassGenricType(final Class clazz) {return getSuperClassGenricType(clazz, 0);}/** * 通过反射,获得定义Class时声明的父类的泛型参数的类型. 如public UserDao extends * HibernateDao<User,Long> *  * @param clazz *            clazz The class to introspect * @param index *            the Index of the generic ddeclaration,start from 0. * @return the index generic declaration, or Object.class if cannot be *         determined */@SuppressWarnings("unchecked")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];}/** * 提取集合中的对象的属性,组合成List. *  * @param collection *            来源集合. * @param propertityName *            要提取的属性名. */@SuppressWarnings("unchecked")public static List fetchElementPropertyToList(final Collection collection, final String propertyName) throws Exception {List list = new ArrayList();for (Object obj : collection) {list.add(PropertyUtils.getProperty(obj, propertyName));}return list;}/** * 提取集合中的对象的属性,组合成由分割符分隔的字符串. *  * @param collection *            来源集合. * @param propertityName *            要提取的属性名. * @param separator *            分隔符. */@SuppressWarnings("unchecked")public static String fetchElementPropertyToString(final Collection collection, final String propertyName, final String separator) throws Exception {List list = fetchElementPropertyToList(collection, propertyName);return StringUtils.join(list.toArray(), separator);}public static void main(String[] args) throws ClassNotFoundException {List<String > list=ReflectionUtils.getDeclaredField(ProductBean.class);//List<String > list=ReflectionUtils.getDeclaredField(Class.forName("com.ocj.pojo.ProductBean"));for (String string : list) {System.out.println(string);}}}

import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.ArrayList;import java.util.List;/** * 泛型工具类 * 获取Class<?>实例后，如果要得到 T 实例，直接T t = (T)c.newInstance()即可得到  * @author luochang */public class GenericsUtils {/** * 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer> *  * @param clazz *            clazz 需要反射的类,该类必须继承范型父类 * @param index *            泛型参数所在索引,从0开始. * @return 范型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回 *         <code>Object.class</code> */@SuppressWarnings("unchecked")public static Class getSuperClassGenricType(Class clazz, int index) {Type genType = clazz.getGenericSuperclass();// 得到泛型父类// 如果没有实现ParameterizedType接口，即不支持泛型，直接返回Object.classif (!(genType instanceof ParameterizedType)) {return Object.class;}// 返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends// DaoSupport<Buyer,Contact>就返回Buyer和Contact类型Type[] params = ((ParameterizedType) genType).getActualTypeArguments();if (index >= params.length || index < 0) {throw new RuntimeException("你输入的索引"+ (index < 0 ? "不能小于0" : "超出了参数的总数"));}if (!(params[index] instanceof Class)) {return Object.class;}return (Class) params[index];}/** * 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer> *  * @param clazz *            clazz 需要反射的类,该类必须继承泛型父类 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回 *         <code>Object.class</code> */@SuppressWarnings("unchecked")public static Class getSuperClassGenricType(Class clazz) {return getSuperClassGenricType(clazz, 0);}/** * 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){} *  * @param Method *            method 方法 * @param int index 泛型参数所在索引,从0开始. * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回 *         <code>Object.class</code> */@SuppressWarnings("unchecked")public static Class getMethodGenericReturnType(Method method, int index) {Type returnType = method.getGenericReturnType();if (returnType instanceof ParameterizedType) {ParameterizedType type = (ParameterizedType) returnType;Type[] typeArguments = type.getActualTypeArguments();if (index >= typeArguments.length || index < 0) {throw new RuntimeException("你输入的索引"+ (index < 0 ? "不能小于0" : "超出了参数的总数"));}return (Class) typeArguments[index];}return Object.class;}/** * 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){} *  * @param Method *            method 方法 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回 *         <code>Object.class</code> */@SuppressWarnings("unchecked")public static Class getMethodGenericReturnType(Method method) {return getMethodGenericReturnType(method, 0);}/** * 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, * Buyer> maps, List<String> names){} *  * @param Method *            method 方法 * @param int index 第几个输入参数 * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合 */@SuppressWarnings("unchecked")public static List<Class> getMethodGenericParameterTypes(Method method,int index) {List<Class> results = new ArrayList<Class>();Type[] genericParameterTypes = method.getGenericParameterTypes();if (index >= genericParameterTypes.length || index < 0) {throw new RuntimeException("你输入的索引"+ (index < 0 ? "不能小于0" : "超出了参数的总数"));}Type genericParameterType = genericParameterTypes[index];if (genericParameterType instanceof ParameterizedType) {ParameterizedType aType = (ParameterizedType) genericParameterType;Type[] parameterArgTypes = aType.getActualTypeArguments();for (Type parameterArgType : parameterArgTypes) {Class parameterArgClass = (Class) parameterArgType;results.add(parameterArgClass);}return results;}return results;}/** * 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> * maps, List<String> names){} *  * @param Method *            method 方法 * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合 */@SuppressWarnings("unchecked")public static List<Class> getMethodGenericParameterTypes(Method method) {return getMethodGenericParameterTypes(method, 0);}/** * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names; *  * @param Field *            field 字段 * @param int index 泛型参数所在索引,从0开始. * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回 *         <code>Object.class</code> */@SuppressWarnings("unchecked")public static Class getFieldGenericType(Field field, int index) {Type genericFieldType = field.getGenericType();if (genericFieldType instanceof ParameterizedType) {ParameterizedType aType = (ParameterizedType) genericFieldType;Type[] fieldArgTypes = aType.getActualTypeArguments();if (index >= fieldArgTypes.length || index < 0) {throw new RuntimeException("你输入的索引"+ (index < 0 ? "不能小于0" : "超出了参数的总数"));}return (Class) fieldArgTypes[index];}return Object.class;}/** * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names; *  * @param Field *            field 字段 * @param int index 泛型参数所在索引,从0开始. * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回 *         <code>Object.class</code> */@SuppressWarnings("unchecked")public static Class getFieldGenericType(Field field) {return getFieldGenericType(field, 0);}}