javaBean与Map<String,Object>互转

1. 为什么要实现javaBean与Map<String,Object>相互转换？

用过spring的都知道spring的MVC框架中有一个BaseCommandController对象，利用这个对象我们就可以很方便的将从客户端传递过来的参数封装到一个JavaBean对象中去，而不需要我们request.getParameter("name");bean.setName(name);了，从而也简化了不少的工作。如果大家用过BeanUtils.populate的话，就知道，这个方法是可以很方便的将request提交的页面表单自动填写到你创建的对象中

2. 如何实现javaBean与Map<String,Object>相互转换？

方法1： 利用java.beans.Introspector和java.beans.PropertyDescriptor实现javaBean与Map<String,Object>互转

方法2： 利用org.apache.commons.beanutils.BeanUtils工具类，BeanUtils.populate实现Map 转换为javaBean

[java] view plain copy

1. packagejavaStudyDemo.bean.reflect.test;
3. importjava.beans.BeanInfo;
4. importjava.beans.Introspector;
5. importjava.beans.PropertyDescriptor;
6. importjava.lang.reflect.Method;
7. importjava.util.HashMap;
8. importjava.util.Map;
9. importjavaStudyDemo.others.PersonBean;
11. importorg.apache.commons.beanutils.BeanUtils;
13. /**
14. *当把Person类作为BeanUtilTest的内部类时，程序出错<br>
15. *java.lang.NoSuchMethodException:Property'**'hasnosettermethod<br>
16. *本质：内部类和单独文件中的类的区别<br>
17. *BeanUtils.populate方法的限制：<br>
18. *Theclassmustbepublic,andprovideapublicconstructorthatacceptsnoarguments.<br>
19. *Thisallowstoolsandapplicationstodynamicallycreatenewinstancesofyourbean,<br>
20. *withoutnecessarilyknowingwhatJavaclassnamewillbeusedaheadoftime
21. */
22. publicclassBeanUtilTest{
24. publicstaticvoidmain(String[]args){
26. PersonBeanperson=newPersonBean();
27. Map<String,Object>mp=newHashMap<String,Object>();
28. mp.put("name","Mike");
29. mp.put("age",25);
30. mp.put("mN","male");
32. //将map转换为bean
33. transMap2Bean2(mp,person);
35. System.out.println("---transMap2BeanMapInfo:");
36. for(Map.Entry<String,Object>entry:mp.entrySet()){
37. System.out.println(entry.getKey()+":"+entry.getValue());
38. }
40. System.out.println("---BeanInfo:");
41. System.out.println("name:"+person.getName());
42. System.out.println("age:"+person.getAge());
43. System.out.println("mN:"+person.getmN());
45. //将javaBean转换为map
46. Map<String,Object>map=transBean2Map(person);
48. System.out.println("---transBean2MapMapInfo:");
49. for(Map.Entry<String,Object>entry:map.entrySet()){
50. System.out.println(entry.getKey()+":"+entry.getValue());
51. }
53. }
55. //Map-->Bean2:利用org.apache.commons.beanutils工具类实现Map-->Bean
56. publicstaticvoidtransMap2Bean2(Map<String,Object>map,Objectobj){
57. if(map==null||obj==null){
58. return;
59. }
60. try{
61. BeanUtils.populate(obj,map);
62. }catch(Exceptione){
63. System.out.println("transMap2Bean2Error"+e);
64. }
65. }
67. //Map-->Bean1:利用Introspector,PropertyDescriptor实现Map-->Bean
68. publicstaticvoidtransMap2Bean(Map<String,Object>map,Objectobj){
70. try{
71. BeanInfobeanInfo=Introspector.getBeanInfo(obj.getClass());
72. PropertyDescriptor[]propertyDescriptors=beanInfo.getPropertyDescriptors();
74. for(PropertyDescriptorproperty:propertyDescriptors){
75. Stringkey=property.getName();
77. if(map.containsKey(key)){
78. Objectvalue=map.get(key);
79. //得到property对应的setter方法
80. Methodsetter=property.getWriteMethod();
81. setter.invoke(obj,value);
82. }
84. }
86. }catch(Exceptione){
87. System.out.println("transMap2BeanError"+e);
88. }
90. return;
92. }
94. //Bean-->Map1:利用Introspector和PropertyDescriptor将Bean-->Map
95. publicstaticMap<String,Object>transBean2Map(Objectobj){
97. if(obj==null){
98. returnnull;
99. }
100. Map<String,Object>map=newHashMap<String,Object>();
101. try{
102. BeanInfobeanInfo=Introspector.getBeanInfo(obj.getClass());
103. PropertyDescriptor[]propertyDescriptors=beanInfo.getPropertyDescriptors();
104. for(PropertyDescriptorproperty:propertyDescriptors){
105. Stringkey=property.getName();
107. //过滤class属性
108. if(!key.equals("class")){
109. //得到property对应的getter方法
110. Methodgetter=property.getReadMethod();
111. Objectvalue=getter.invoke(obj);
113. map.put(key,value);
114. }
116. }
117. }catch(Exceptione){
118. System.out.println("transBean2MapError"+e);
119. }
121. returnmap;
123. }
124. }

[java] view plain copy

1. publicclassPersonBean{
3. privateStringname;
4. privateIntegerage;
5. privateStringmN;
7. /**
8. *@returnthemN
9. */
10. publicStringgetmN(){
11. returnmN;
12. }
14. /**
15. *@parammNthemNtoset
16. */
17. publicvoidsetmN(StringmN){
18. this.mN=mN;
19. }
22. /**
23. *@returnthename
24. */
25. publicStringgetName(){
26. returnname;
27. }
29. /**
30. *@paramnamethenametoset
31. */
32. publicvoidsetName(Stringname){
33. this.name=name;
34. }
36. /**
37. *@returntheage
38. */
39. publicIntegergetAge(){
40. returnage;
41. }
43. /**
44. *@paramagetheagetoset
45. */
46. publicvoidsetAge(Integerage){
47. this.age=age;
48. }
50. }

总结： javaBean与Map<String,Object>互转利用到了java的内省（Introspector）和反射（reflect）机制。 其思路为：通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器PropertyDescriptor，再利用属性描述器获取某个属性对应的getter/setter方法，然后通过反射机制来getter和setter。

什么是内省？

内省是Java语言对Bean类属性、事件的一种缺省处理方法。例如类PersonBean中有属性name,那我们可以通过getName,setName来得到其值或者设置新的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter/setter方法，通过这些API可以使你不需要了解这个规则（但你最好还是要搞清楚），这些API存放于包java.beans中。注意： PersonBean中属性mN的getter/setter方法必须满足javaBean命名规范，即getmN，不能写作getMN，否则转换失败。详情参考 http://blog.renren.com/share/236384819/5598710664