反射工具类源码

　　JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

　　Java Reflection

　　　　Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

　　Java反射机制提供的功能

　　　　在运行时判断任意一个对象所属的类

　　　　在运行时构造任意一个类的对象

　　　　在运行时判断任意一个类所具有的成员变量和方法

　　　　在运行时调用任意一个对象的成员变量和方法

　　　　生成动态代理

　　反射相关的主要API：

　　　　java.lang.Class:代表一个类

　　　　java.lang.reflect.Method:代表类的方法

　　　　java.lang.reflect.Field:代表类的成员变量

　　　　java.lang.reflect.Constructor:代表类的构造方法

 　。。。。。。

 

 

import java.lang.reflect.Field;  2 import java.lang.reflect.InvocationTargetException;  3 import java.lang.reflect.Method;  4 import java.lang.reflect.Modifier;  5 import java.lang.reflect.ParameterizedType;  6 import java.lang.reflect.Type;  7 
import org.apache.commons.lang3.StringUtils;  9 import org.apache.commons.lang3.Validate;  10 import org.slf4j.Logger;  11 import org.slf4j.LoggerFactory;  12 import org.springframework.util.Assert;  13 
/**
 * 反射工具类.  16  * 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数.  17  */
//压制警告，即去除警告 
@SuppressWarnings("rawtypes")  20 public class Reflections {  21     
    private static final String SETTER_PREFIX = "set";  23 
    private static final String GETTER_PREFIX = "get";  25 
    private static final String CGLIB_CLASS_SEPARATOR = "$$";  27     
    private static Logger logger = LoggerFactory.getLogger(Reflections.class);  29 
    /**
 * 调用Getter方法.  32  * 支持多级，如：对象名.对象名.方法  33      */
    public static Object invokeGetter(Object obj, String propertyName) {  35         Object object = obj;  36         for (String name : StringUtils.split(propertyName, ".")){  37             String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);  38             object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});  39  }  40         return object;  41  }  42 
    /**
 * 调用Setter方法, 仅匹配方法名。  45  * 支持多级，如：对象名.对象名.方法  46      */
    public static void invokeSetter(Object obj, String propertyName, Object value) {  48         Object object = obj;  49         String[] names = StringUtils.split(propertyName, ".");  50         for (int i=0; i<names.length; i++){  51             if(i<names.length-1){  52                 String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);  53                 object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});  54             }else{  55                 String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);  56                 invokeMethodByName(object, setterMethodName, new Object[] { value });  57  }  58  }  59  }  60 
    /**
 * 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.  63      */
    public static Object getFieldValue(final Object obj, final String fieldName) {  65         Field field = getAccessibleField(obj, fieldName);  66 
        if (field == null) {  68             throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");  69  }  70 
        Object result = null;  72         try {  73             result = field.get(obj);  74         } catch (IllegalAccessException e) {  75             logger.error("不可能抛出的异常{}", e.getMessage());  76  }  77         return result;  78  }  79 
    /**
 * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.  82      */
    public static void setFieldValue(final Object obj, final String fieldName, final Object value) {  84         Field field = getAccessibleField(obj, fieldName);  85 
        if (field == null) {  87             throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");  88  }  89 
        try {  91  field.set(obj, value);  92         } catch (IllegalAccessException e) {  93             logger.error("不可能抛出的异常:{}", e.getMessage());  94  }  95  }  96 
    /**
 * 直接调用对象方法, 无视private/protected修饰符.  99  * 用于一次性调用的情况，否则应使用getAccessibleMethod()函数获得Method后反复调用. 100  * 同时匹配方法名+参数类型， 101      */
    public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes, 103             final Object[] args) { 104         Method method = getAccessibleMethod(obj, methodName, parameterTypes); 105         if (method == null) { 106             throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]"); 107  } 108 
        try { 110             return method.invoke(obj, args); 111         } catch (Exception e) { 112             throw convertReflectionExceptionToUnchecked(e); 113  } 114  } 115 
    /**
 * 直接调用对象方法, 无视private/protected修饰符， 118  * 用于一次性调用的情况，否则应使用getAccessibleMethodByName()函数获得Method后反复调用. 119  * 只匹配函数名，如果有多个同名函数调用第一个。 120      */
    public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) { 122         Method method = getAccessibleMethodByName(obj, methodName); 123         if (method == null) { 124             throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]"); 125  } 126 
        try { 128             return method.invoke(obj, args); 129         } catch (Exception e) { 130             throw convertReflectionExceptionToUnchecked(e); 131  } 132  } 133 
    /**
 * 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问. 136  * 137  * 如向上转型到Object仍无法找到, 返回null. 138      */
    public static Field getAccessibleField(final Object obj, final String fieldName) { 140         Validate.notNull(obj, "object can't be null"); 141         Validate.notBlank(fieldName, "fieldName can't be blank"); 142         for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) { 143             try { 144                 Field field = superClass.getDeclaredField(fieldName); 145  makeAccessible(field); 146                 return field; 147             } catch (NoSuchFieldException e) {//NOSONAR 148                 // Field不在当前类定义,继续向上转型
                continue;// new add
 } 151  } 152         return null; 153  } 154 
    /**
 * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问. 157  * 如向上转型到Object仍无法找到, 返回null. 158  * 匹配函数名+参数类型。 159  * 160  * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args) 161      */
    public static Method getAccessibleMethod(final Object obj, final String methodName, 163             final Class<?>... parameterTypes) { 164         Validate.notNull(obj, "object can't be null"); 165         Validate.notBlank(methodName, "methodName can't be blank"); 166 
        for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) { 168             try { 169                 Method method = searchType.getDeclaredMethod(methodName, parameterTypes); 170  makeAccessible(method); 171                 return method; 172             } catch (NoSuchMethodException e) { 173                 // Method不在当前类定义,继续向上转型
                continue;// new add
 } 176  } 177         return null; 178  } 179 
    /**
 * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问. 182  * 如向上转型到Object仍无法找到, 返回null. 183  * 只匹配函数名。 184  * 185  * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args) 186      */
    public static Method getAccessibleMethodByName(final Object obj, final String methodName) { 188         Validate.notNull(obj, "object can't be null"); 189         Validate.notBlank(methodName, "methodName can't be blank"); 190 
        for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) { 192             Method[] methods = searchType.getDeclaredMethods(); 193             for (Method method : methods) { 194                 if (method.getName().equals(methodName)) { 195  makeAccessible(method); 196                     return method; 197  } 198  } 199  } 200         return null; 201  } 202 
    /**
 * 改变private/protected的方法为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。 205      */
    public static void makeAccessible(Method method) { 207         if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers())) 208                 && !method.isAccessible()) { 209             method.setAccessible(true); 210  } 211  } 212 
    /**
 * 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。 215      */
    public static void makeAccessible(Field field) { 217         if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier 218                 .isFinal(field.getModifiers())) && !field.isAccessible()) { 219             field.setAccessible(true); 220  } 221  } 222 
    /**
 * 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处 225  * 如无法找到, 返回Object.class. 226  * eg. 227  * public UserDao extends HibernateDao<User> 228  * 229  * @param clazz The class to introspect 230  * @return the first generic declaration, or Object.class if cannot be determined 231      */
    @SuppressWarnings("unchecked") 233     public static <T> Class<T> getClassGenricType(final Class clazz) { 234         return getClassGenricType(clazz, 0); 235  } 236 
    /**
 * 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 239  * 如无法找到, 返回Object.class. 240  * 241  * 如public UserDao extends HibernateDao<User,Long> 242  * 243  * @param clazz clazz The class to introspect 244  * @param index the Index of the generic ddeclaration,start from 0. 245  * @return the index generic declaration, or Object.class if cannot be determined 246      */
    public static Class getClassGenricType(final Class clazz, final int index) { 248 
        Type genType = clazz.getGenericSuperclass(); 250 
        if (!(genType instanceof ParameterizedType)) { 252             logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType"); 253             return Object.class; 254  } 255 
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); 257 
        if (index >= params.length || index < 0) { 259             logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
                    + params.length); 261             return Object.class; 262  } 263         if (!(params[index] instanceof Class)) { 264             logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter"); 265             return Object.class; 266  } 267 
        return (Class) params[index]; 269  } 270     
    public static Class<?> getUserClass(Object instance) { 272         Assert.notNull(instance, "Instance must not be null"); 273         Class clazz = instance.getClass(); 274         if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) { 275             Class<?> superClass = clazz.getSuperclass(); 276             if (superClass != null && !Object.class.equals(superClass)) { 277                 return superClass; 278  } 279  } 280         return clazz; 281 
 } 283     
    /**
 * 将反射时的checked exception转换为unchecked exception. 286      */
    public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) { 288         if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException 289                 || e instanceof NoSuchMethodException) { 290             return new IllegalArgumentException(e); 291         } else if (e instanceof InvocationTargetException) { 292             return new RuntimeException(((InvocationTargetException) e).getTargetException()); 293         } else if (e instanceof RuntimeException) { 294             return (RuntimeException) e; 295  } 296         return new RuntimeException("Unexpected Checked Exception.", e); 297  } 298 }

 

 

转载请注明出处！

http://www.cnblogs.com/libingbin/

感谢您的阅读。如果文章对您有用，那么请轻轻点个赞，以资鼓励。