java web开发将请求的参数转换为bean对象

在一些应用中使用较为方便，比如你插入一行数据，通过Post或Get请求得到所有参数，而在一些时候我们是要直接操作对于数据行的一个bean对象，下面的是一个扩展性较好的方法。

注：常规编程时可以简单操作，如下一个bean

[java]  view plain copy

1. public class Student implements java.io.Serializable{  
2.     private static final long serialVersionUID = 1L;  
3.       
4.     private String studentid;  
5.     private String studentname;  
6.     private String studentbir;  
7.     private String studentsex;  
8.       
9.     public String getStudentid() {  
10.         return studentid;  
11.     }  
12.   
13.     public void setStudentid(String studentid) {  
14.         this.studentid = studentid;  
15.     }  
16.   
17.     public String getStudentname() {  
18.         return studentname;  
19.     }  
20.   
21.     public void setStudentname(String studentname) {  
22.         this.studentname = studentname;  
23.     }  
24.   
25.     public String getStudentbir() {  
26.         return studentbir;  
27.     }  
28.   
29.     public void setStudentbir(String studentbir) {  
30.         this.studentbir = studentbir;  
31.     }  
32.   
33.     public String getStudentsex() {  
34.         return studentsex;  
35.     }  
36.   
37.     public void setStudentsex(String studentsex) {  
38.         this.studentsex = studentsex;  
39.     }  
40.       
41.       
42. }  

假设视图层将通过Post表单提交一个这样的参数集合：studentid=001,studentname='xiaoli',studentbir='1992-1-27',studentsex='男'

我们在控制层通过多个getParameter()得到对于数据，接下来new Student(),对象赋值得到一个Student的bean,后面再使用什么spring之类的Dao层就插入数据库中持久化了。

以上方法简单也比较好理解，但是扩展性不好，你要是有成百上千个bean，那代码量都是这样，可想而知，冗余，维修性差……

 

2、下面是在一个项目中借鉴的操作性较好的方法，将任何请求（Post/ Get），参数混乱中的情况下拿到bean：

面向对象好处在之一少不了封装：下面是将任何请求所有参数封装为一个Map<String ,Object>,直接在控制层执行Map<String, Object> m=RequestUtils.getQueryParams(request);就可以啦，下面就是在工具类RequestUtils实现这个静态方法：

 

[java]  view plain copy

1. @SuppressWarnings("unchecked")  
2.     public static Map<String, Object> getQueryParams(HttpServletRequest request) {  
3.         Map<String, String[]> map;  
4.         if (request.getMethod().equalsIgnoreCase(POST)) {  
5.             map = request.getParameterMap();  
6.         } else {  
7.             //为GET请求时就获取其请求参数的那段信息  
8.             String s = request.getQueryString();  
9.             if (StringUtils.isBlank(s)) {  
10.                 return new HashMap<String, Object>();  
11.             }  
12.             try {  
13.                 //将得到的HTML数据用UTF-8转码  
14.                 s = URLDecoder.decode(s, UTF8);  
15.             } catch (UnsupportedEncodingException e) {  
16.                 log.error("encoding " + UTF8 + " not support?", e);  
17.             }  
18.             map = parseQueryString(s);  
19.         }  
20.   
21.         Map<String, Object> params = new HashMap<String, Object>(map.size());  
22.         int len;  
23.         for (Map.Entry<String, String[]> entry : map.entrySet()) {  
24.             len = entry.getValue().length;  
25.             if (len == 1) {  
26.                 params.put(entry.getKey(), entry.getValue()[0]);  
27.             } else if (len > 1) {  
28.                 params.put(entry.getKey(), entry.getValue());  
29.             }  
30.         }  
31.         return params;  
32.     }  

上面看出，两种请求下做了不同处理，最后将所有参数键值转化为一个Map，

这样之后就可以在控制层用String action=m.get("action").toString();的形式得到各种参数；

前面说了一个项目bean成百个，所有将参数集转化为bean也进行封装，如调用时：Student s=(OrgList) BeanConverter.toJavaBean(new Student(), m,true);m为上面得到的Map参数映射表，具体实现要使用到了Java的反射机制处理，也就是根据传入的bean对象，得到这个对象所在类，并获取到这个类的所有声明了的方法：Method[] methods = javabean.getClass().getDeclaredMethods();再循环得到打头为set的方法，拿到这个方法的名字如setStudentsex转换为一个参数studentsex,然后将这个参数与map中的key做识别，有相同的key便将其value插入该bean中，具体实现如下：

[java]  view plain copy

1. public static Object toJavaBean(Object javabean, Map<String, Object> m,Boolean zhuanma)   
2.    {   
3.     //System.out.println(m);  
4.     //所有声明了的方法  
5.        Method[] methods = javabean.getClass().getDeclaredMethods();   
6.        for (Method method : methods)   
7.        {   
8.                if (method.getName().startsWith("set"))   
9.                {   
10.                 //得到该方法的参数类型  
11.                 Class<?>[] params = method.getParameterTypes();  
12.                    String field = method.getName();   
13.                    field = field.substring(field.indexOf("set") + 3);   
14.                    field = field.toLowerCase().charAt(0) + field.substring(1);   
15.                    //System.out.println(field+"----"+m.get(field.toString()));  
16.                    Object value=m.get(field.toString());  
17.                    try {  
18.                        // convert types for some popular ones  
19.                        if (value != null&&!"".equals(value)) {  
20.                         String pa=params[0].getName().toString();  
21.                         //if (value instanceof java.util.Date) {  
22.                                if (pa.equals("java.util.Date")) {  
23.                                    value = new java.util.Date(((java.util.Date) value).getTime());  
24.                                }  
25. //                           }  
26.                            else if(pa.equals("java.lang.String")){  
27.                             //value= new java.lang.String(Function.PageToDb(value.toString()));  
28.                             if(zhuanma)value= new java.lang.String(Function.PageToDb(value.toString()));  
29.                            }  
30.                            else if(pa.equals("java.lang.Integer")||pa.equals("int")){  
31.                              value= new java.lang.Integer(value.toString());  
32.                            }else if (pa.equals("java.lang.Long")) {  
33.                                 value= new java.lang.Long(value.toString());  
34.                            } else if (pa.equals("java.lang.Double")) {  
35.                              value= new java.lang.Double(value.toString());  
36.   
37.                            } else if (pa.equals("java.lang.Float")) {  
38.                              value= new java.lang.Float(value.toString());  
39.   
40.                            } else if (pa.equals("java.lang.Short")) {  
41.                              value= new java.lang.Short(value.toString());  
42.   
43.                            } else if (pa.equals("java.lang.Byte")) {  
44.                              value= new java.lang.Byte(value.toString());  
45.   
46.                            } else if (pa.equals("java.lang.Character")) {  
47.                             // value= new java.lang.Character(value);  
48.   
49.                            } else if (pa.equals("java.lang.Boolean")) {  
50.                              value= new java.lang.Boolean(value.toString());  
51.   
52.                            }   
53.                                  
54.                                // Don't call setter if the value object isn't the right type   
55.                                if (isCompatibleType(value, params[0])) {  
56.                                    method.invoke(javabean, new Object[] { value });  
57.                                } else {  
58.                                  throw new Exception(  
59.                                      "Cannot set " + field.toString() + ": incompatible types.");  
60.                                }  
61.                        }  
62.                } catch(Exception e){  
63.                 e.printStackTrace();  
64.                }  
65.        }   
66.                }  
67.   
68.        return javabean;   
69.    }   

 

上面看起来有点复杂，但实际项目中个人认为较为实用，但可能还有其它个好的解决方案，这里只将个人学习所得记录，自我学习。