Java将前台传递的数据封装为各种类型

本文转载自查看原文 2017-10-23 19:16 1301 JAVA基础
  1 import java.lang.reflect.Field;
  2 import java.lang.reflect.Method;
  3 import java.sql.Timestamp;
  4 import java.util.ArrayList;
  5 import java.util.Date;
  6 import java.util.HashMap;
  7 import java.util.Iterator;
  8 import java.util.List;
  9 import java.util.Map;
 10 import java.util.Set;
 11 
 12 import javax.servlet.http.HttpServletRequest;
 13 
 14 /**
 15  * Created with IntelliJ IDEA. User: alabo Date: 13-7-12 Time: 下午3:52 To change this template use File | Settings | File
 16  * Templates.
 17  */
 18 public class BeanUtil
 19 {
 20     
 21     /**
 22      * 根据bean从request中反射构造pojo
 23      *
 24      * @param request
 25      * @param beanClass
 26      * @return
 27      */
 28     public static Object getBeanFromRequest(HttpServletRequest request, Class beanClass)
 29     {
 30         try
 31         {
 32             Object object = beanClass.newInstance();
 33             Field[] fields = beanClass.getDeclaredFields();
 34             for (Field field : fields)
 35             {
 36                 String fieldName = field.getName();
 37                 String methodName =
 38                     "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, fieldName.length());
 39                 Class fieldType = field.getType();
 40                 if (fieldType.isInstance(new String()))
 41                 {
 42                     String fieldValue = RequestUtil.getString(request, fieldName);
 43                     Method method = beanClass.getMethod(methodName, String.class);
 44                     method.invoke(object, fieldValue);
 45                 }
 46                 else if (fieldType.isInstance(new Integer(1)))
 47                 {
 48                     Integer fieldValue = RequestUtil.getInteger(request, fieldName);
 49                     if (fieldType != null)
 50                     {
 51                         Method method = beanClass.getMethod(methodName, Integer.class);
 52                         method.invoke(object, fieldValue);
 53                     }
 54                 }
 55                 else if (fieldType.isInstance(new Long(1)))
 56                 {
 57                     Long fieldValue = RequestUtil.getLong(request, fieldName);
 58                     if (fieldType != null)
 59                     {
 60                         Method method = beanClass.getMethod(methodName, Long.class);
 61                         method.invoke(object, fieldValue);
 62                     }
 63                 }
 64                 else if (fieldType.isInstance(new Date()))
 65                 {
 66                     Date fieldValue = RequestUtil.getDate(request, fieldName);
 67                     if (fieldType != null)
 68                     {
 69                         Method method = beanClass.getMethod(methodName, Date.class);
 70                         method.invoke(object, fieldValue);
 71                     }
 72                 }
 73                 else if (fieldType.isInstance(new Timestamp(System.currentTimeMillis())))
 74                 {
 75                     Timestamp fieldValue = RequestUtil.getTimestamp(request, fieldName);
 76                     if (fieldType != null)
 77                     {
 78                         Method method = beanClass.getMethod(methodName, Timestamp.class);
 79                         method.invoke(object, fieldValue);
 80                     }
 81                 }
 82             }
 83             
 84             return object;
 85         }
 86         catch (Exception e)
 87         {
 88             e.printStackTrace();
 89             return null;
 90         }
 91     }
 92     
 93     /**
 94      * 从request构造查询map
 95      *
 96      * @param request
 97      * @return
 98      */
 99     public static Map<String, Object> getMapFromRequest(HttpServletRequest request)
100     {
101         Map<String, Object> map = new HashMap<String, Object>();
102         Map paramtMap = request.getParameterMap();
103         Set set = paramtMap.keySet();
104         Iterator iterator = set.iterator();
105         while (iterator.hasNext())
106         {
107             String key = (String)iterator.next();
108             String value = RequestUtil.getString(request, key);
109             if (!value.equals(""))
110             { // 当参数值为空，则不传递此参数
111                 map.put(key, value);
112             }
113         }
114         // 默认加载分页参数
115         String start = RequestUtil.getString(request, "start", "0");
116         String end = RequestUtil.getString(request, "end", "0");
117         map.put("start", Integer.parseInt(start));
118         map.put("end", Integer.parseInt(end));
119         /*
120          * if (null != map.get("end") && null != map.get("start")) { Integer pageSize =
121          * Integer.parseInt(map.get("end").toString()) - Integer.parseInt(map.get("start").toString()); map.put("end",
122          * pageSize); }
123          */
124         return map;
125     }
126     
127     /**
128      * 从request构造查询map 用于参数值中包含List或者Array的情况
129      *
130      * @param request
131      * @return
132      */
133     public static Map<String, Object> getMapFromRequestAdn(HttpServletRequest request)
134     {
135         Map<String, Object> map = new HashMap<String, Object>();
136         Map paramtMap = request.getParameterMap();
137         Set set = paramtMap.keySet();
138         Iterator iterator = set.iterator();
139         while (iterator.hasNext())
140         {
141             String key = (String)iterator.next();
142             String value = RequestUtil.getString(request, key);
143             if (!value.equals(""))
144             { // 当参数值为空，则不传递此参数
145                 map.put(key, value);
146             }
147         }
148         // 默认加载分页参数
149         String start = RequestUtil.getString(request, "start", "0");
150         String end = RequestUtil.getString(request, "end", "0");
151         map.put("start", Integer.parseInt(start));
152         map.put("end", Integer.parseInt(end));
153         
154         return map;
155     }
156     
157     /**
158      * 根据bean结构，从request反射构造bean的list
159      *
160      * @param request
161      * @param beanClass
162      * @return
163      */
164     public static List getBeanListFromRequest(HttpServletRequest request, Class beanClass)
165     {
166         try
167         {
168             List beanList = new ArrayList();
169             String className = beanClass.getName();
170             String beanName = className.substring(className.lastIndexOf(".") + 1, className.length());
171             beanName = beanName.substring(0, 1).toLowerCase() + beanName.substring(1, beanName.length());
172             Field[] fields = beanClass.getDeclaredFields();
173             int flag = 0;
174             for (int i = 0; i < 300; i++)
175             {
176                 Object object = beanClass.newInstance();
177                 for (Field field : fields)
178                 {
179                     String fieldName = field.getName();
180                     String methodName =
181                         "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, fieldName.length());
182                     Class fieldType = field.getType();
183                     String param = beanName + "[" + i + "][" + fieldName + "]";
184                     if (fieldType.isInstance(new String()))
185                     {
186                         String fieldValue = RequestUtil.getString(request, param);
187                         if (fieldValue != null && !"".equals(fieldValue))
188                         {
189                             Method method = beanClass.getMethod(methodName, String.class);
190                             method.invoke(object, fieldValue);
191                         }
192                         else
193                         {
194                             flag++;
195                         }
196                     }
197                     else if (fieldType.isInstance(new Integer(1)))
198                     {
199                         Integer fieldValue = RequestUtil.getInteger(request, param);
200                         if (fieldValue != null)
201                         {
202                             Method method = beanClass.getMethod(methodName, Integer.class);
203                             method.invoke(object, fieldValue);
204                         }
205                         else
206                         {
207                             flag++;
208                         }
209                     }
210                     else if (fieldType.toString().equals("int"))
211                     {
212                         Integer fieldValue = RequestUtil.getInteger(request, param);
213                         if (fieldValue != null)
214                         {
215                             Method method = beanClass.getMethod(methodName, int.class);
216                             method.invoke(object, fieldValue.intValue());
217                         }
218                         else
219                         {
220                             flag++;
221                         }
222                     }
223                     else if (fieldType.isInstance(new Long(1)))
224                     {
225                         Long fieldValue = RequestUtil.getLong(request, param);
226                         if (fieldValue != null)
227                         {
228                             Method method = beanClass.getMethod(methodName, Long.class);
229                             method.invoke(object, fieldValue);
230                         }
231                         else
232                         {
233                             flag++;
234                         }
235                     }
236                     else if (fieldType.toString().equals("long"))
237                     {
238                         Long fieldValue = RequestUtil.getLong(request, param);
239                         if (fieldValue != null)
240                         {
241                             Method method = beanClass.getMethod(methodName, long.class);
242                             method.invoke(object, fieldValue.longValue());
243                         }
244                         else
245                         {
246                             flag++;
247                         }
248                     }
249                     else if (fieldType.isInstance(new Date()))
250                     {
251                         Date fieldValue = RequestUtil.getDate(request, param);
252                         if (fieldValue != null)
253                         {
254                             Method method = beanClass.getMethod(methodName, Date.class);
255                             method.invoke(object, fieldValue);
256                         }
257                         else
258                         {
259                             flag++;
260                         }
261                     }
262                 }
263                 if (flag >= fields.length)
264                 {
265                     break;
266                 }
267                 else
268                 {
269                     beanList.add(object);
270                     flag = 0;
271                 }
272             }
273             
274             return beanList;
275         }
276         catch (Exception e)
277         {
278             e.printStackTrace();
279             return null;
280         }
281     }
282     
283     /**
284      * 根据bean结构，从request反射构造map的list
285      *
286      * @param request
287      * @param beanClass
288      * @return
289      */
290     public static List<Map<String, String>> getMapListFromRequest(HttpServletRequest request, Class beanClass)
291     {
292         try
293         {
294             List<Map<String, String>> mapList = new ArrayList<Map<String, String>>();
295             
296             String className = beanClass.getName();
297             String beanName = className.substring(className.lastIndexOf(".") + 1, className.length());
298             beanName = beanName.substring(0, 1).toLowerCase() + beanName.substring(1, beanName.length());
299             Field[] fields = beanClass.getDeclaredFields();
300             int flag = 0;
301             for (int i = 0; i < 100; i++)
302             {
303                 Map<String, String> map = new HashMap<String, String>();
304                 for (Field field : fields)
305                 {
306                     String fieldName = field.getName();
307                     Class fieldType = field.getType();
308                     if (fieldType.isInstance(new String()))
309                     {
310                         String param = beanName + "[" + i + "][" + fieldName + "]";
311                         String fieldValue = RequestUtil.getString(request, param);
312                         if (!fieldValue.equals(""))
313                         {
314                             map.put(fieldName, fieldValue);
315                         }
316                         else
317                         {
318                             flag++;
319                         }
320                     }
321                 }
322                 if (flag >= fields.length)
323                 {
324                     break;
325                 }
326                 else
327                 {
328                     mapList.add(map);
329                     flag = 0;
330                 }
331             }
332             
333             return mapList;
334         }
335         catch (Exception e)
336         {
337             e.printStackTrace();
338             return null;
339         }
340     }
341     
342     public static void main(String[] args)
343         throws Exception
344     {
345     }
346 }
免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。
猜您在找 JAVA-各种类型之间转换 parse() 与valueOf() Java运行时，各种类型存储介绍【工具类】Java中各种类型判空 cxf开发webservice服务器+客户端（各种类型的参数传递返回） Java项目返回数据封装 + swagger2 postman测试接口各种类型传值 tk mybatis update 各种类型 Flume的各种类型的组件介绍 MATLAB 可以画的各种类型的图总结各种类型转换LPCTSTR方法