Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.penglecode.common.util;
  
  import java.util.Arrays;
  
反射工具类

Author(s):
pengpeng
Version:
1.0
Date:
2014年7月19日 下午7:12:07
 
 public class ReflectionUtils {

获得超类的参数类型,取第一个参数类型

Parameters:
<T> 类型参数
clazz 超类类型
   
     @SuppressWarnings("rawtypes")  
     public static Class<?> getClassGenricType(final Class clazz) {
         return getClassGenricType(clazz, 0);
     }
    
    
根据索引获得超类的参数类型

Parameters:
clazz 超类类型
index 索引
   
     @SuppressWarnings("rawtypes")  
     public static Class getClassGenricType(final Class clazzfinal int index) {
     	Assert.notNull(clazz"Parameter 'clazz' must be not null!");
     	Assert.state(index > -1, "Parameter 'index' must be > -1!");
         Type genType = clazz.getGenericSuperclass();  
         if (!(genType instanceof ParameterizedType)) {  
             return Object.class;  
         }  
         Type[] params = ((ParameterizedType)genType).getActualTypeArguments();  
         if (index >= params.length || index < 0) {  
             return Object.class;  
         }  
         if (!(params[indexinstanceof Class)) {  
             return Object.class;  
         }  
         return (Classparams[index];  
     }
     
     public static Class<?> getFieldGenricType(final Field field) {
     	return getFieldGenricType(field, 0);
     }
     
     @SuppressWarnings("rawtypes")
 	public static Class getFieldGenricType(final Field fieldfinal int index) {
     	Assert.notNull(field"Parameter 'field' must be not null!");
     	Assert.state(index > -1, "Parameter 'index' must be > -1!");
     	Type type = field.getGenericType();
     	if(type instanceof ParameterizedType){
 			type = ptype.getActualTypeArguments()[index];
 			if(type instanceof ParameterizedType){
 				return (Class)((ParameterizedTypetype).getRawType();
 			}else{
 				return (Classtype;
 			}
 		}else{
 			return (Classtype;
 		}
     }
    

根据属性字段名称获取@{code java.lang.reflect.Field}

Parameters:
targetClass
fieldName
Returns:
 
 	public static Field findField(Class<?> targetClassString fieldName) {
 		Assert.notNull(targetClass"Parameter 'targetClass' must be not null!");
 		Assert.hasText(fieldName"Parameter 'fieldName' must be not empty!");
 		Class<?> searchType = targetClass;
 		while (!Object.class.equals(searchType) && searchType != null) {
 			Field[] fields = searchType.getDeclaredFields();
 			for (Field field : fields) {
 				if (fieldName.equals(field.getName())) {
 					return field;
 				}
 			}
 			searchType = searchType.getSuperclass();
 		}
 		return null;
 	}

在目标对象上设置属性字段的值(包括修改final字段的值)

Parameters:
field
target
value
	public static void setFieldValue(Field fieldObject targetObject value) {
		try {
			field.setAccessible(true);
			field.set(targetvalue);
catch (Exception e) {
			throw new ReflectionException(String.format("setting field's value failed by reflection! error message is: %s"e.getMessage()), e);
		}
	}

在目标对象上获取属性字段的值

Parameters:
field
target
Returns:
	@SuppressWarnings("unchecked")
	public static <T> T getFieldValue(Field fieldObject target) {
		try {
			field.setAccessible(true);
			return (T) field.get(target);
catch (Exception e) {
			throw new ReflectionException(String.format("getting field's value failed by reflection! error message is: %s"e.getMessage()), e);
		}
	}

根据方法名字及入参在类中查找方法

Parameters:
targetClass
methodName
paramTypes
Returns:
	public static Method findMethod(Class<?> targetClassString methodNameClass<?>... paramTypes) {
		Assert.notNull(targetClass"Parameter 'targetClass' can not be null!");
		Assert.hasText(methodName"Parameter 'methodName' can not be empty!");
		Class<?> searchType = targetClass;
		while (searchType != null) {
			Method[] methods = (searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods());
			for (Method method : methods) {
				if (methodName.equals(method.getName())
						&& (paramTypes == null || Arrays.equals(paramTypesmethod.getParameterTypes()))) {
					return method;
				}
			}
			searchType = searchType.getSuperclass();
		}
		return null;
	}

根据方法名字在类中查找其无参方法

Parameters:
targetClass
methodName
Returns:
	public static Method findMethod(Class<?> targetClassString methodName) {
		return findMethod(targetClassmethodNamenew Class[0]);
	}

在某个对象上调用某个无参方法

Parameters:
method
target
Returns:
	public static <T> T invokeMethod(Method methodObject target) {
		return invokeMethod(methodtargetnew Object[0]);
	}

在某个对象上调用某个有参方法

Parameters:
method - Method方法对象
target - 方法所属目标对象
args - 方法入参
Returns:
	@SuppressWarnings("unchecked")
	public static <T> T invokeMethod(Method methodObject targetObject... args) {
		try {
			method.setAccessible(true);
			return (T) method.invoke(targetargs);
catch (Exception e) {
			throw new ReflectionException(String.format("invoke method failed by reflection! error message is: %s"e.getMessage()), e);
		}
	}
	public static class ReflectionException extends RuntimeException {
		private static final long serialVersionUID = 1L;
		public ReflectionException(String messageThrowable cause) {
			super(messagecause);
		}
		public ReflectionException(String message) {
			super(message);
		}
		public ReflectionException(Throwable cause) {
			super(cause);
		}
	}
New to GrepCode? Check out our FAQ X