java反射，ReflectUtils

 public class ReflectUtils {
     /**
      * 通过构造函数实例化对象
      * @param className       类的全路径名称
      * @param parameterTypes  参数类型
      * @param initargs        参数值
      * @return
      */
     @SuppressWarnings("rawtypes")
     public static Object constructorNewInstance(String className,Class [] parameterTypes,Object[] initargs) {
         try {
             Constructor<?> constructor = (Constructor<?>) Class
                     .forName(className).getDeclaredConstructor(parameterTypes);
             constructor.setAccessible(true);
             return constructor.newInstance(initargs);
         } catch (Exception ex) {
             throw new RuntimeException();
         }  

     }  

     /**
      * 获取字段值
      * @param propertyName 属性名
      * @param object       实例对象
      * @return          字段值
      */
     public static Object getProperty(String propertyName, Object object) {
         try {  

             PropertyDescriptor pd = new PropertyDescriptor(propertyName,object.getClass());
             Method method = pd.getReadMethod();
             return method.invoke(object);
         } catch (Exception ex) {
             throw new RuntimeException();
         }
     }  

     /**
      * 通过BeanUtils工具包获取反射获取字段值,注意此值是以字符串形式存在的,它支持属性连缀操作:如,.对象.属性
      * @param propertyName 属性名
      * @param object       实例对象
      * @return          字段值
      */
     public static Object getBeanInfoProperty(String propertyName, Object object) {
         try {
             return BeanUtils.getProperty(object, propertyName);
         } catch (Exception ex) {
             throw new RuntimeException();
         }
     }  

     /**
      * 通过BeanUtils工具包获取反射获取字段值,注意此值是以字符串形式存在的
      * @param object       实例对象
      * @param propertyName 属性名
      * @param value        字段值
      * @return
      */
     public static void setBeanInfoProperty(Object object,String propertyName,String value) {
         try {
             BeanUtils.setProperty(object, propertyName,value);
         } catch (Exception ex) {
             throw new RuntimeException();
         }
     }  

     /**
      * 通过BeanUtils工具包获取反射获取字段值,注意此值是以对象属性的实际类型
      * @param propertyName 属性名
      * @param object       实例对象
      * @return          字段值
      */
     public static Object getPropertyUtilByName(String propertyName, Object object) {
         try {
             return PropertyUtils.getProperty(object, propertyName);
         } catch (Exception ex) {
             throw new RuntimeException();
         }
     }  

     /**
      * 通过BeanUtils工具包获取反射获取字段值,注意此值是以对象属性的实际类型,这是PropertyUtils与BeanUtils的根本区别
      * @param object       实例对象
      * @param propertyName 属性名
      * @param value        字段值
      * @return
      */
     public static void setPropertyUtilByName(Object object,String propertyName,Object value) {
         try {
             PropertyUtils.setProperty(object, propertyName,value);
         } catch (Exception ex) {
             throw new RuntimeException();
         }
     }  

     /**
      * 设置字段值
      * @param obj          实例对象
      * @param propertyName 属性名
      * @param value        新的字段值
      * @return
      */
     public static void setProperties(Object object, String propertyName,Object value) throws IntrospectionException,
             IllegalAccessException, InvocationTargetException {
         PropertyDescriptor pd = new PropertyDescriptor(propertyName,object.getClass());
         Method methodSet = pd.getWriteMethod();
         methodSet.invoke(object,value);
     }  

     /**
      * 设置字段值
      * @param className        类的全路径名称
      * @param methodName       调用方法名
      * @param parameterTypes   参数类型
      * @param values           参数值
      * @param object           实例对象
      * @return
      */
     @SuppressWarnings("rawtypes")
     public static Object methodInvoke(String className,String methodName,Class [] parameterTypes,Object [] values,Object object) {
         try {
             Method method = Class.forName(className).getDeclaredMethod(methodName,parameterTypes);
             method.setAccessible(true);
             return method.invoke(object,values);
         } catch (Exception ex) {
             throw new RuntimeException();
         }
     }    

     /**
      * @param <T> 具体对象
      * @param fileds  要进行比较Bean对象的属性值集合(以属性值为key,属性注释为value,集合从数据库中取出)
      * @param oldBean  源对象
      * @param newBean  新对象
      * @return 返回二个Bean对象属性值的异同
      */
     @SuppressWarnings("unused")
     public static <T> String compareBeanValue(Map<String,String> fileds,T oldBean,T newBean){  

         StringBuilder compares = new StringBuilder();
         String propertyName = null;
         Object oldPropertyValue = null;
         Object newPropertyValue = null;  

         StringBuilder descrips = new StringBuilder();
         for(Map.Entry<String, String> entity : fileds.entrySet()){
             propertyName = entity.getKey().toLowerCase();
             oldPropertyValue = getProperty(propertyName, oldBean);
             newPropertyValue = getProperty(propertyName, newBean);            

             if(null == oldPropertyValue && null == newPropertyValue){
                 continue;
             }
             if("".equals(oldPropertyValue) && "".equals(newPropertyValue)){
                 continue;
             }
             if(null == oldPropertyValue){
                 oldPropertyValue = "";
             }
             if(null == newPropertyValue){
                 newPropertyValue = "";
             }             

             if(oldPropertyValue.equals(newPropertyValue)){
                 continue;
             }
             compares.append("字段注释: ").append(entity.getValue()).append("】").append("原属性值\"");
             if(StringUtils.isEmpty(oldPropertyValue+"")){
                 oldPropertyValue = " ";
             }
             compares.append(oldPropertyValue).append("\"现属性值\"");
             if(StringUtils.isEmpty(newPropertyValue+"")){
                 newPropertyValue = " ";
             }
             compares.append(newPropertyValue).append("\";");
         }
         return compares.toString();
     }

     /***
      * 暴力反射获取字段值
      * @param obj       实例对象
      * @param fieldName 属性名
      * @return          属性值
      */
     public static Object getFieldValue(Object obj, String fieldName){
         if(obj == null){
             return null ;
         }
         Field targetField = getTargetField(obj.getClass(), fieldName);  

         try {
             return FieldUtils.readField(targetField, obj, true ) ;
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
         return null ;
     }

     public static Field getTargetField(Class<?> targetClass, String fieldName) {
         Field field = null;  

         try {
             if (targetClass == null) {
                 return field;
             }  

             if (Object.class.equals(targetClass)) {
                 return field;
             }  

             field = FieldUtils.getDeclaredField(targetClass, fieldName, true);
             if (field == null) {
                 field = getTargetField(targetClass.getSuperclass(), fieldName);
             }
         } catch (Exception e) {
         }  

         return field;
     }

     /**
      * 设置字段值
      * @param propertyName 字段名
      * @param obj          实例对象
      * @param value        新的字段值
      * @return
      */
     public static void setFieldValue(Object obj , String fieldName , Object value ){
         if(null == obj){return;}
         Field targetField = getTargetField(obj.getClass(), fieldName);
         try {
              FieldUtils.writeField(targetField, obj, value) ;
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
     }