您的位置: 首页  >  IT文章  >  利用java反照原理写了一个简单赋值和取值通用类

利用java反照原理写了一个简单赋值和取值通用类

分类: IT文章 • 2024-08-04 14:36:01
利用java反射原理写了一个简单赋值和取值通用类

由于项目的实际需要，所以利用java反射原理写了一个简单给bean赋值和取值通用的类，在此记录下方便自己日后用到，也为需要的兄弟提供个参考例子。 
     当然目前这个版本还有很多需要改进的地方，比如还没有添加对byte、char等的支持，主要是当前项目基本用不到这些类型，所以也没有多加考虑，以后会补上的。 

直接附上java代码的：BeanRefUtil.java 

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

运行结果如下： 
通过反射赋值. 
通过反射取值: 
flag---false 
height---173.5 
times---1287932898276 
age---27 
userName---michael 
date---2010-10-24 00:00:00 

 

转载自：http://sjsky.iteye.com/blog/792819

相关推荐