一起写框架-MVC框架-基础功能-Date类型数据绑定(七)

实现功能

表单请求传递的数据，格式为以下格式的日期时间数据。

（1）：yyyy-MM-dd hh:mm:ss

（2）：yyyy-MM-dd

执行方法可以使用Date类型接收。

实现思路

1.获得表单字符串。判断是否符合Date的格式。使用DataFormat转成成Date。

实现代码

1.原来数据绑定的代码都堆在ControllerRelolver，这样导致ControllerRelolver臃肿了。所以创建一个DataBind数据绑定类，将数据绑定的代码移进里面。

  1 package ioc.webmvc.impl;
  2 
  3 import java.lang.reflect.Parameter;
  4 import java.text.ParseException;
  5 import java.text.SimpleDateFormat;
  6 import java.util.Date;
  7 
  8 import javax.servlet.ServletContext;
  9 import javax.servlet.ServletRequest;
 10 import javax.servlet.ServletResponse;
 11 import javax.servlet.http.HttpServletRequest;
 12 import javax.servlet.http.HttpServletResponse;
 13 import javax.servlet.http.HttpSession;
 14 
 15 import ioc.webmvc.annotation.Param;
 16 
 17 public class DataBind {
 18     /**
 19      * 绑定作用域对象
 20      * @param typeClass
 21      * @param request
 22      * @param response
 23      * @param session
 24      * @param application
 25      * @return
 26      */
 27     public static Object bindScope(Class<?> typeClass, HttpServletRequest request, HttpServletResponse response,
 28             HttpSession session, ServletContext application) {
 29         if (ServletRequest.class.isAssignableFrom(typeClass)) {
 30             return request;
 31         } else if (ServletResponse.class.isAssignableFrom(typeClass)) {
 32             return response;
 33         } else if (HttpSession.class.isAssignableFrom(typeClass)) {
 34             return session;
 35         } else if (ServletContext.class.isAssignableFrom(typeClass)) {
 36             return application;
 37         }
 38         return null;
 39     }
 40 
 41     /**
 42      * 绑定基础数据类型
 43      * 
 44      * @param typeClass
 45      * @param parameter
 46      * @param request
 47      * @return
 48      */
 49     public static Object bindBasicData(Class<?> typeClass, Parameter parameter, HttpServletRequest request) {
 50         Param param = parameter.getAnnotation(Param.class);
 51         if (param == null) {
 52             throw new RuntimeException("自定义参数没有使用@Param注解绑定");
 53         }
 54         System.out.println(param.value());
 55         // 获得参数值
 56         String parameterValue = request.getParameter(param.value());
 57 
 58         if (String.class.isAssignableFrom(typeClass)) {
 59             // 4.判断基础数据类型的String类型
 60             return request.getParameter(param.value());
 61         } else if (Long.class.isAssignableFrom(typeClass)) {
 62             // 5.判断基础数据类型的Long类型
 63             if (parameterValue != null && !"".equals(parameterValue)) {
 64                 return Long.valueOf(parameterValue);
 65             }
 66 
 67         } else if (Integer.class.isAssignableFrom(typeClass)) {
 68             // 6.判断基础数据类型的Integer类型
 69             if (parameterValue != null && !"".equals(parameterValue)) {
 70                 return Integer.valueOf(parameterValue);
 71             }
 72 
 73         } else if (Double.class.isAssignableFrom(typeClass)) {
 74             // 7.判断基础数据类型的Double类型
 75             if (parameterValue != null && !"".equals(parameterValue)) {
 76                 return Double.valueOf(parameterValue);
 77             }
 78 
 79         } else if (Float.class.isAssignableFrom(typeClass)) {
 80             // 8.判断基础数据类型的Float类型
 81             if (parameterValue != null && !"".equals(parameterValue)) {
 82                 return Float.valueOf(parameterValue);
 83             }
 84 
 85         } else if (Boolean.class.isAssignableFrom(typeClass)) {
 86             // 9.判断基础数据类型的Boolean类型
 87             if (parameterValue != null && !"".equals(parameterValue)) {
 88                 return Boolean.valueOf(parameterValue);
 89             }
 90 
 91         } else if (Character.class.isAssignableFrom(typeClass)) {
 92             // 10.判断基础数据类型的Character类型
 93             if (parameterValue != null && !"".equals(parameterValue)) {
 94                 String s = new String(parameterValue);
 95                 return s.toCharArray()[0];
 96             }
 97 
 98         } else if (Short.class.isAssignableFrom(typeClass)) {
 99             // 11.判断基础数据类型的Short类型
100             if (parameterValue != null && !"".equals(parameterValue)) {
101                 return Short.valueOf(parameterValue);
102             }
103 
104         } else if (Byte.class.isAssignableFrom(typeClass)) {
105             // 12.判断基础数据类型的Byte类型
106             if (parameterValue != null && !"".equals(parameterValue)) {
107                 return Byte.valueOf(parameterValue);
108             }
109         } else if (long.class.isAssignableFrom(typeClass)) {
110             // 5.判断基础数据类型的long类型
111             if (parameterValue != null && !"".equals(parameterValue)) {
112                 return Long.valueOf(parameterValue);
113             } else {
114                 return 0;
115             }
116 
117         } else if (int.class.isAssignableFrom(typeClass)) {
118             // 6.判断基础数据类型的int类型
119             if (parameterValue != null && !"".equals(parameterValue)) {
120                 return Integer.valueOf(parameterValue);
121             } else {
122                 return 0;
123             }
124 
125         } else if (double.class.isAssignableFrom(typeClass)) {
126             // 7.判断基础数据类型的double类型
127             if (parameterValue != null && !"".equals(parameterValue)) {
128                 return Double.valueOf(parameterValue);
129             } else {
130                 return 0.0;
131             }
132 
133         } else if (float.class.isAssignableFrom(typeClass)) {
134             // 8.判断基础数据类型的float类型
135             if (parameterValue != null && !"".equals(parameterValue)) {
136                 return Float.valueOf(parameterValue);
137             } else {
138                 return 0.0f;
139             }
140 
141         } else if (boolean.class.isAssignableFrom(typeClass)) {
142             // 9.判断基础数据类型的boolean类型
143             if (parameterValue != null && !"".equals(parameterValue)) {
144                 return Boolean.valueOf(parameterValue);
145             } else {
146                 return true;
147             }
148 
149         } else if (char.class.isAssignableFrom(typeClass)) {
150 
151             // 10.判断基础数据类型的char类型
152             if (parameterValue != null && !"".equals(parameterValue)) {
153                 String s = new String(parameterValue);
154                 return s.toCharArray()[0];
155             } else {
156                 return ' ';
157             }
158 
159         } else if (short.class.isAssignableFrom(typeClass)) {
160             // 11.判断基础数据类型的short类型
161             if (parameterValue != null && !"".equals(parameterValue)) {
162                 return Short.valueOf(parameterValue);
163             } else {
164                 return 0;
165             }
166 
167         } else if (byte.class.isAssignableFrom(typeClass)) {
168 
169             // 12.判断基础数据类型的byte类型
170             if (parameterValue != null && !"".equals(parameterValue)) {
171                 return Byte.valueOf(parameterValue);
172             } else {
173                 return 0;
174             }
175 
176         }
177         return null;
178 
179     }
180 
181     /**
182      * 绑定日期类型,默认支持的格式为： 1.yyyy-mm-dd hh:mm:ss 2.yyyy-mm-dd
183      * 
184      * @param typeClass
185      * @param parameter
186      * @param request
187      * @return
188      */
189     public static Object bindDate(Class<?> typeClass, Parameter parameter, HttpServletRequest request) {
190         if (Date.class.isAssignableFrom(typeClass)) {
191 
192             // 10.判断基础数据类型的char类型
193             Param param = parameter.getAnnotation(Param.class);
194             System.out.println("--绑定字段名 :" + param.value());
195             String parameterValue = request.getParameter(param.value());
196             String pattern = null;
197 
198             if (parameterValue != null && !"".equals(parameterValue)) {
199                 if (parameterValue.lastIndexOf(":") > 0) {
200                     pattern = "yyyy-MM-dd hh:mm:ss";
201                 } else {
202                     pattern = "yyyy-MM-dd";
203                 }
204                 SimpleDateFormat format = new SimpleDateFormat(pattern);
205 
206                 try {
207                     return format.parse(parameterValue);
208                 } catch (ParseException e) {
209                     e.printStackTrace();
210                 }
211             }
212 
213         }
214         return null;
215     }
216 
217 
218 
219 }

 2.修改ControllerRelolver类的绑定参数的方法getparameterObjects

 1 private Object[] getparameterObjects(Parameter[] parameters) {
 2         // 1.创建设置一个参数对象的数组，参数的格式和参数类型的个一致
 3         Object[] parameterObjects = new Object[parameters.length];
 4         //2.根据参数的类型，将对于的对象填在对象数组中
 5         for(int i=0;i<parameters.length;i++){
 6             
 7             Class<?> typeClass = parameters[i].getType();
 8             //3.根据判断方法参数的类型和我们制定的4个作用是否是父子类关系。如果是就赋值
 9             //---绑定域对象request,reponse,session,application
10             Object scopeData = DataBind.bindScope(typeClass, request, response, session, application);
11             //---绑定基础数据类型------------------------------
12             if(scopeData!=null){
13                 parameterObjects[i]=scopeData;
14                 continue;
15             }
16             Object basicData = DataBind.bindBasicData(typeClass, parameters[i], request);
17              if(basicData!=null){
18                     parameterObjects[i]=basicData;
19                     continue;
20              }
21             //---绑定日期格式-------
22             Object dateData =DataBind.bindDate(typeClass, parameters[i], request);
23              if(dateData!=null){
24                     parameterObjects[i]=dateData;
25                     continue;
26             }
27             //---绑定数组数据
28             Object arrayData = DataBind.bindArray(typeClass, parameters[i], request);
29             if(arrayData!=null){
30                 parameterObjects[i]=arrayData;
31                 continue;
32             }
33             
34         }
35         return parameterObjects;
36     }

测试代码

1.测试目录

1.测试页面代码

 1 <%@ page language="java" contentType="text/html; charset=UTF-8"
 2     pageEncoding="UTF-8"%>
 3 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 4 <html>
 5 <head>
 6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 7 <title>Insert title here</title>
 8 </head>
 9 <body>
10     用户注册
11      <form action="${pageContext.request.contextPath }/register.do" method="post">
12        用户名：<input name="username" type="text" /><br/>
13        密码：  <input name="password" type="text" /><br/>
14        年龄：    <input name="age" type="text" /><br/>
15      出生日期：   <input name="date" type="date"><br/>
16          <input type="submit" value="注册">
17      </form>
18 </body>
19 </html>

2.测试的Controller代码

 1     /**
 2      * 注册页面
 3      * @param username
 4      * @param password
 5      * @return
 6      */
 7     @RequestMapping(value = "/register")
 8     public String register(@Param("username") String username,@Param("password") String password ,@Param("age") long age,HttpServletRequest request,@Param("date") Date date){
 9         System.out.println("用户名:"+username+",密码:"+password+"，年龄"+age);
10         System.out.println(request.getRequestURI());
11         System.out.println(date);
12         return "redirect:/register.jsp";
13     }

3.测试结果

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhuyuejiu/p/7821608.html