Java反射 - 简单的给Bean赋值和取值

由于项目的实际需要，所以利用java反射原理写了一个简单给bean赋值和取值通用的类，在此记录下方便自己日后用到，也为需要的兄弟提供个参考例子。 

工具类BeanRefUtil：

[java] view plain copy
 print?
  1. package com.test;    
  2.     
  3. import java.lang.reflect.Field;    
  4. import java.lang.reflect.Method;    
  5. import java.text.SimpleDateFormat;    
  6. import java.util.Date;    
  7. import java.util.HashMap;    
  8. import java.util.Locale;    
  9. import java.util.Map;    
  10.     
  11. /**  
  12.  * java bean 反射的方法  
  13.  */    
  14. public class BeanRefUtil {    
  15.     
  16.     /**  
  17.      * 取Bean的属性和值对应关系的MAP  
  18.      * @param bean  
  19.      * @return Map  
  20.      */    
  21.     public static Map<String, String> getFieldValueMap(Object bean) {    
  22.         Class<?> cls = bean.getClass();    
  23.         Map<String, String> valueMap = new HashMap<String, String>();    
  24.         // 取出bean里的所有方法    
  25.         Method[] methods = cls.getDeclaredMethods();    
  26.         Field[] fields = cls.getDeclaredFields();    
  27.     
  28.         for (Field field : fields) {    
  29.             try {    
  30.                 String fieldType = field.getType().getSimpleName();    
  31.                 String fieldGetName = parGetName(field.getName());    
  32.                 if (!checkGetMet(methods, fieldGetName)) {    
  33.                     continue;    
  34.                 }    
  35.                 Method fieldGetMet = cls    
  36.                         .getMethod(fieldGetName, new Class[] {});    
  37.                 Object fieldVal = fieldGetMet.invoke(bean, new Object[] {});    
  38.                 String result = null;    
  39.                 if ("Date".equals(fieldType)) {    
  40.                     result = fmtDate((Date) fieldVal);    
  41.                 } else {    
  42.                     if (null != fieldVal) {    
  43.                         result = String.valueOf(fieldVal);    
  44.                     }    
  45.                 }    
  46.                 valueMap.put(field.getName(), result);    
  47.             } catch (Exception e) {    
  48.                 continue;    
  49.             }    
  50.         }    
  51.         return valueMap;    
  52.     
  53.     }    
  54.     
  55.     /**  
  56.      * set属性的值到Bean  
  57.      * @param bean  
  58.      * @param valMap  
  59.      */    
  60.     public static void setFieldValue(Object bean, Map<String, String> valMap) {    
  61.         Class<?> cls = bean.getClass();    
  62.         // 取出bean里的所有方法    
  63.         Method[] methods = cls.getDeclaredMethods();    
  64.         Field[] fields = cls.getDeclaredFields();    
  65.     
  66.         for (Field field : fields) {    
  67.             try {    
  68.     
  69.                 String fieldSetName = parSetName(field.getName());    
  70.                 if (!checkSetMet(methods, fieldSetName)) {    
  71.                     continue;    
  72.                 }    
  73.                 Method fieldSetMet = cls.getMethod(fieldSetName, field    
  74.                         .getType());    
  75.                 String value = valMap.get(field.getName());    
  76.                 if (null != value && !"".equals(value)) {    
  77.                     String fieldType = field.getType().getSimpleName();    
  78.                     if ("String".equals(fieldType)) {    
  79.                         fieldSetMet.invoke(bean, value);    
  80.                     } else if ("Date".equals(fieldType)) {    
  81.                         Date temp = parseDate(value);    
  82.                         fieldSetMet.invoke(bean, temp);    
  83.                     } else if ("Integer".equals(fieldType)    
  84.                             || "int".equals(fieldType)) {    
  85.                         Integer intval = Integer.parseInt(value);    
  86.                         fieldSetMet.invoke(bean, intval);    
  87.                     } else if ("Long".equalsIgnoreCase(fieldType)) {    
  88.                         Long temp = Long.parseLong(value);    
  89.                         fieldSetMet.invoke(bean, temp);    
  90.                     } else if ("Double".equalsIgnoreCase(fieldType)) {    
  91.                         Double temp = Double.parseDouble(value);    
  92.                         fieldSetMet.invoke(bean, temp);    
  93.                     } else if ("Boolean".equalsIgnoreCase(fieldType)) {    
  94.                         Boolean temp = Boolean.parseBoolean(value);    
  95.                         fieldSetMet.invoke(bean, temp);    
  96.                     } else {    
  97.                         System.out.println("not supper type" + fieldType);    
  98.                     }    
  99.                 }    
  100.             } catch (Exception e) {    
  101.                 continue;    
  102.             }    
  103.         }    
  104.     
  105.     }    
  106.     
  107.     /**  
  108.      * 格式化string为Date  
  109.      * @param datestr  
  110.      * @return date  
  111.      */    
  112.     public static Date parseDate(String datestr) {    
  113.         if (null == datestr || "".equals(datestr)) {    
  114.             return null;    
  115.         }    
  116.         try {    
  117.             String fmtstr = null;    
  118.             if (datestr.indexOf(':') > 0) {    
  119.                 fmtstr = "yyyy-MM-dd HH:mm:ss";    
  120.             } else {    
  121.     
  122.                 fmtstr = "yyyy-MM-dd";    
  123.             }    
  124.             SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK);    
  125.             return sdf.parse(datestr);    
  126.         } catch (Exception e) {    
  127.             return null;    
  128.         }    
  129.     }    
  130.     
  131.     /**  
  132.      * 日期转化为String  
  133.      * @param date  
  134.      * @return date string  
  135.      */    
  136.     public static String fmtDate(Date date) {    
  137.         if (null == date) {    
  138.             return null;    
  139.         }    
  140.         try {    
  141.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",    
  142.                     Locale.US);    
  143.             return sdf.format(date);    
  144.         } catch (Exception e) {    
  145.             return null;    
  146.         }    
  147.     }    
  148.     
  149.     /**  
  150.      * 判断是否存在某属性的 set方法  
  151.      * @param methods  
  152.      * @param fieldSetMet  
  153.      * @return boolean  
  154.      */    
  155.     public static boolean checkSetMet(Method[] methods, String fieldSetMet) {    
  156.         for (Method met : methods) {    
  157.             if (fieldSetMet.equals(met.getName())) {    
  158.                 return true;    
  159.             }    
  160.         }    
  161.         return false;    
  162.     }    
  163.     
  164.     /**  
  165.      * 判断是否存在某属性的 get方法  
  166.      * @param methods  
  167.      * @param fieldGetMet  
  168.      * @return boolean  
  169.      */    
  170.     public static boolean checkGetMet(Method[] methods, String fieldGetMet) {    
  171.         for (Method met : methods) {    
  172.             if (fieldGetMet.equals(met.getName())) {    
  173.                 return true;    
  174.             }    
  175.         }    
  176.         return false;    
  177.     }    
  178.     
  179.     /**  
  180.      * 拼接某属性的 get方法  
  181.      * @param fieldName  
  182.      * @return String  
  183.      */    
  184.     public static String parGetName(String fieldName) {    
  185.         if (null == fieldName || "".equals(fieldName)) {    
  186.             return null;    
  187.         }    
  188.         return "get" + fieldName.substring(0, 1).toUpperCase()    
  189.                 + fieldName.substring(1);    
  190.     }    
  191.     
  192.     /**  
  193.      * 拼接在某属性的 set方法  
  194.      * @param fieldName  
  195.      * @return String  
  196.      */    
  197.     public static String parSetName(String fieldName) {    
  198.         if (null == fieldName || "".equals(fieldName)) {    
  199.             return null;    
  200.         }    
  201.         return "set" + fieldName.substring(0, 1).toUpperCase()    
  202.                 + fieldName.substring(1);    
  203.     }    
  204.     
  205. }    


posted @ 2018-05-03 15:34  星朝  阅读(6295)  评论(0)  编辑  收藏  举报