网上图书商城项目学习笔记-036工具类之CommonUtils及日期转换器
1.CommonUtils.java
1 package cn.itcast.commons; 2 3 import java.util.Map; 4 import java.util.UUID; 5 6 import org.apache.commons.beanutils.BeanUtils; 7 import org.apache.commons.beanutils.ConvertUtils; 8 9 /** 10 * 小小工具 11 * @author qdmmy6 12 * 13 */ 14 public class CommonUtils { 15 /** 16 * 返回一个不重复的字符串 17 * @return 18 */ 19 public static String uuid() { 20 return UUID.randomUUID().toString().replace("-", "").toUpperCase(); 21 } 22 23 /** 24 * 把map转换成对象 25 * @param map 26 * @param clazz 27 * @return 28 * 29 * 把Map转换成指定类型 30 */ 31 @SuppressWarnings("rawtypes") 32 public static <T> T toBean(Map map, Class<T> clazz) { 33 try { 34 /* 35 * 1. 通过参数clazz创建实例 36 * 2. 使用BeanUtils.populate把map的数据封闭到bean中 37 */ 38 T bean = clazz.newInstance(); 39 ConvertUtils.register(new DateConverter(), java.util.Date.class); 40 BeanUtils.populate(bean, map); 41 return bean; 42 } catch(Exception e) { 43 throw new RuntimeException(e); 44 } 45 } 46 }
2.DateConverter.java
1 package cn.itcast.commons; 2 3 import java.text.ParseException; 4 import java.text.SimpleDateFormat; 5 6 import org.apache.commons.beanutils.Converter; 7 8 /** 9 * 把String转换成java.util.Date的类型转换器 10 * @author qdmmy6 11 * 12 */ 13 public class DateConverter implements Converter { 14 15 @SuppressWarnings("rawtypes") 16 @Override 17 public Object convert(Class type, Object value) { 18 if(value == null) return null;//如果要转换成值为null，那么直接返回null 19 if(!(value instanceof String)) {//如果要转换的值不是String，那么就不转换了，直接返回 20 return value; 21 } 22 String val = (String) value;//把值转换成String 23 24 // 使用SimpleDateFormat进行转换 25 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); 26 try { 27 return sdf.parse(val); 28 } catch (ParseException e) { 29 throw new RuntimeException(e); 30 } 31 } 32 }
3..BeanUtils.java
1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 19 package org.apache.commons.beanutils; 20 21 import java.lang.reflect.InvocationTargetException; 22 import java.util.Map; 23 24 25 26 /** 27 * <p>Utility methods for populating JavaBeans properties via reflection.</p> 28 * 29 * <p>The implementations are provided by {@link BeanUtilsBean}. 30 * These static utility methods use the default instance. 31 * More sophisticated behaviour can be provided by using a <code>BeanUtilsBean</code> instance.</p> 32 * 33 * @author Craig R. McClanahan 34 * @author Ralph Schaer 35 * @author Chris Audley 36 * @author Rey Francois 37 * @author Gregor Rayman 38 * @version $Revision: 690380 $ $Date: 2008-08-29 21:04:38 +0100 (Fri, 29 Aug 2008) $ 39 * @see BeanUtilsBean 40 */ 41 42 public class BeanUtils { 43 44 45 // ------------------------------------------------------ Private Variables 46 47 48 /** 49 * The debugging detail level for this component. 50 * 51 * Note that this static variable will have unexpected side-effects if 52 * this class is deployed in a shared classloader within a container. 53 * However as it is actually completely ignored by this class due to its 54 * deprecated status, it doesn't do any actual harm. 55 * 56 * @deprecated BeanUtils now uses commons-logging for all log messages. 57 * Use your favorite logging tool to configure logging for 58 * this class. 59 */ 60 private static int debug = 0; 61 62 /** 63 * The <code>debug</code> static property is no longer used 64 * @return debug property 65 * @deprecated BeanUtils now uses commons-logging for all log messages. 66 * Use your favorite logging tool to configure logging for 67 * this class. 68 */ 69 public static int getDebug() { 70 return (debug); 71 } 72 73 /** 74 * The <code>debug</code> static property is no longer used 75 * @param newDebug debug property 76 * @deprecated BeanUtils now uses commons-logging for all log messages. 77 * Use your favorite logging tool to configure logging for 78 * this class. 79 */ 80 public static void setDebug(int newDebug) { 81 debug = newDebug; 82 } 83 84 // --------------------------------------------------------- Class Methods 85 86 87 /** 88 * <p>Clone a bean based on the available property getters and setters, 89 * even if the bean class itself does not implement Cloneable.</p> 90 * 91 * <p>For more details see <code>BeanUtilsBean</code>.</p> 92 * 93 * @param bean Bean to be cloned 94 * @return the cloned bean 95 * 96 * @exception IllegalAccessException if the caller does not have 97 * access to the property accessor method 98 * @exception InstantiationException if a new instance of the bean's 99 * class cannot be instantiated 100 * @exception InvocationTargetException if the property accessor method 101 * throws an exception 102 * @exception NoSuchMethodException if an accessor method for this 103 * property cannot be found 104 * @see BeanUtilsBean#cloneBean 105 */ 106 public static Object cloneBean(Object bean) 107 throws IllegalAccessException, InstantiationException, 108 InvocationTargetException, NoSuchMethodException { 109 110 return BeanUtilsBean.getInstance().cloneBean(bean); 111 112 } 113 114 115 /** 116 * <p>Copy property values from the origin bean to the destination bean 117 * for all cases where the property names are the same.</p> 118 * 119 * <p>For more details see <code>BeanUtilsBean</code>.</p> 120 * 121 * @param dest Destination bean whose properties are modified 122 * @param orig Origin bean whose properties are retrieved 123 * 124 * @exception IllegalAccessException if the caller does not have 125 * access to the property accessor method 126 * @exception IllegalArgumentException if the <code>dest</code> or 127 * <code>orig</code> argument is null or if the <code>dest</code> 128 * property type is different from the source type and the relevant 129 * converter has not been registered. 130 * @exception InvocationTargetException if the property accessor method 131 * throws an exception 132 * @see BeanUtilsBean#copyProperties 133 */ 134 public static void copyProperties(Object dest, Object orig) 135 throws IllegalAccessException, InvocationTargetException { 136 137 BeanUtilsBean.getInstance().copyProperties(dest, orig); 138 } 139 140 141 /** 142 * <p>Copy the specified property value to the specified destination bean, 143 * performing any type conversion that is required.</p> 144 * 145 * <p>For more details see <code>BeanUtilsBean</code>.</p> 146 * 147 * @param bean Bean on which setting is to be performed 148 * @param name Property name (can be nested/indexed/mapped/combo) 149 * @param value Value to be set 150 * 151 * @exception IllegalAccessException if the caller does not have 152 * access to the property accessor method 153 * @exception InvocationTargetException if the property accessor method 154 * throws an exception 155 * @see BeanUtilsBean#copyProperty 156 */ 157 public static void copyProperty(Object bean, String name, Object value) 158 throws IllegalAccessException, InvocationTargetException { 159 160 BeanUtilsBean.getInstance().copyProperty(bean, name, value); 161 } 162 163 164 /** 165 * <p>Return the entire set of properties for which the specified bean 166 * provides a read method.</p> 167 * 168 * <p>For more details see <code>BeanUtilsBean</code>.</p> 169 * 170 * @param bean Bean whose properties are to be extracted 171 * @return Map of property descriptors 172 * 173 * @exception IllegalAccessException if the caller does not have 174 * access to the property accessor method 175 * @exception InvocationTargetException if the property accessor method 176 * throws an exception 177 * @exception NoSuchMethodException if an accessor method for this 178 * property cannot be found 179 * @see BeanUtilsBean#describe 180 */ 181 public static Map describe(Object bean) 182 throws IllegalAccessException, InvocationTargetException, 183 NoSuchMethodException { 184 185 return BeanUtilsBean.getInstance().describe(bean); 186 } 187 188 189 /** 190 * <p>Return the value of the specified array property of the specified 191 * bean, as a String array.</p> 192 * 193 * <p>For more details see <code>BeanUtilsBean</code>.</p> 194 * 195 * @param bean Bean whose property is to be extracted 196 * @param name Name of the property to be extracted 197 * @return The array property value 198 * 199 * @exception IllegalAccessException if the caller does not have 200 * access to the property accessor method 201 * @exception InvocationTargetException if the property accessor method 202 * throws an exception 203 * @exception NoSuchMethodException if an accessor method for this 204 * property cannot be found 205 * @see BeanUtilsBean#getArrayProperty 206 */ 207 public static String[] getArrayProperty(Object bean, String name) 208 throws IllegalAccessException, InvocationTargetException, 209 NoSuchMethodException { 210 211 return BeanUtilsBean.getInstance().getArrayProperty(bean, name); 212 } 213 214 215 /** 216 * <p>Return the value of the specified indexed property of the specified 217 * bean, as a String.</p> 218 * 219 * <p>For more details see <code>BeanUtilsBean</code>.</p> 220 * 221 * @param bean Bean whose property is to be extracted 222 * @param name <code>propertyname[index]</code> of the property value 223 * to be extracted 224 * @return The indexed property's value, converted to a String 225 * 226 * @exception IllegalAccessException if the caller does not have 227 * access to the property accessor method 228 * @exception InvocationTargetException if the property accessor method 229 * throws an exception 230 * @exception NoSuchMethodException if an accessor method for this 231 * property cannot be found 232 * @see BeanUtilsBean#getIndexedProperty(Object, String) 233 */ 234 public static String getIndexedProperty(Object bean, String name) 235 throws IllegalAccessException, InvocationTargetException, 236 NoSuchMethodException { 237 238 return BeanUtilsBean.getInstance().getIndexedProperty(bean, name); 239 240 } 241 242 243 /** 244 * Return the value of the specified indexed property of the specified 245 * bean, as a String. The index is specified as a method parameter and 246 * must *not* be included in the property name expression 247 * 248 * <p>For more details see <code>BeanUtilsBean</code>.</p> 249 * 250 * @param bean Bean whose property is to be extracted 251 * @param name Simple property name of the property value to be extracted 252 * @param index Index of the property value to be extracted 253 * @return The indexed property's value, converted to a String 254 * 255 * @exception IllegalAccessException if the caller does not have 256 * access to the property accessor method 257 * @exception InvocationTargetException if the property accessor method 258 * throws an exception 259 * @exception NoSuchMethodException if an accessor method for this 260 * property cannot be found 261 * @see BeanUtilsBean#getIndexedProperty(Object, String, int) 262 */ 263 public static String getIndexedProperty(Object bean, 264 String name, int index) 265 throws IllegalAccessException, InvocationTargetException, 266 NoSuchMethodException { 267 268 return BeanUtilsBean.getInstance().getIndexedProperty(bean, name, index); 269 270 } 271 272 273 /** 274 * </p>Return the value of the specified indexed property of the specified 275 * bean, as a String.</p> 276 * 277 * <p>For more details see <code>BeanUtilsBean</code>.</p> 278 * 279 * @param bean Bean whose property is to be extracted 280 * @param name <code>propertyname(index)</code> of the property value 281 * to be extracted 282 * @return The mapped property's value, converted to a String 283 * 284 * @exception IllegalAccessException if the caller does not have 285 * access to the property accessor method 286 * @exception InvocationTargetException if the property accessor method 287 * throws an exception 288 * @exception NoSuchMethodException if an accessor method for this 289 * property cannot be found 290 * @see BeanUtilsBean#getMappedProperty(Object, String) 291 */ 292 public static String getMappedProperty(Object bean, String name) 293 throws IllegalAccessException, InvocationTargetException, 294 NoSuchMethodException { 295 296 return BeanUtilsBean.getInstance().getMappedProperty(bean, name); 297 298 } 299 300 301 /** 302 * </p>Return the value of the specified mapped property of the specified 303 * bean, as a String.</p> 304 * 305 * <p>For more details see <code>BeanUtilsBean</code>.</p> 306 * 307 * @param bean Bean whose property is to be extracted 308 * @param name Simple property name of the property value to be extracted 309 * @param key Lookup key of the property value to be extracted 310 * @return The mapped property's value, converted to a String 311 * 312 * @exception IllegalAccessException if the caller does not have 313 * access to the property accessor method 314 * @exception InvocationTargetException if the property accessor method 315 * throws an exception 316 * @exception NoSuchMethodException if an accessor method for this 317 * property cannot be found 318 * @see BeanUtilsBean#getMappedProperty(Object, String, String) 319 */ 320 public static String getMappedProperty(Object bean, 321 String name, String key) 322 throws IllegalAccessException, InvocationTargetException, 323 NoSuchMethodException { 324 325 return BeanUtilsBean.getInstance().getMappedProperty(bean, name, key); 326 327 } 328 329 330 /** 331 * <p>Return the value of the (possibly nested) property of the specified 332 * name, for the specified bean, as a String.</p> 333 * 334 * <p>For more details see <code>BeanUtilsBean</code>.</p> 335 * 336 * @param bean Bean whose property is to be extracted 337 * @param name Possibly nested name of the property to be extracted 338 * @return The nested property's value, converted to a String 339 * 340 * @exception IllegalAccessException if the caller does not have 341 * access to the property accessor method 342 * @exception IllegalArgumentException if a nested reference to a 343 * property returns null 344 * @exception InvocationTargetException if the property accessor method 345 * throws an exception 346 * @exception NoSuchMethodException if an accessor method for this 347 * property cannot be found 348 * @see BeanUtilsBean#getNestedProperty 349 */ 350 public static String getNestedProperty(Object bean, String name) 351 throws IllegalAccessException, InvocationTargetException, 352 NoSuchMethodException { 353 354 return BeanUtilsBean.getInstance().getNestedProperty(bean, name); 355 356 } 357 358 359 /** 360 * <p>Return the value of the specified property of the specified bean, 361 * no matter which property reference format is used, as a String.</p> 362 * 363 * <p>For more details see <code>BeanUtilsBean</code>.</p> 364 * 365 * @param bean Bean whose property is to be extracted 366 * @param name Possibly indexed and/or nested name of the property 367 * to be extracted 368 * @return The property's value, converted to a String 369 * 370 * @exception IllegalAccessException if the caller does not have 371 * access to the property accessor method 372 * @exception InvocationTargetException if the property accessor method 373 * throws an exception 374 * @exception NoSuchMethodException if an accessor method for this 375 * property cannot be found 376 * @see BeanUtilsBean#getProperty 377 */ 378 public static String getProperty(Object bean, String name) 379 throws IllegalAccessException, InvocationTargetException, 380 NoSuchMethodException { 381 382 return BeanUtilsBean.getInstance().getProperty(bean, name); 383 384 } 385 386 387 /** 388 * <p>Return the value of the specified simple property of the specified 389 * bean, converted to a String.</p> 390 * 391 * <p>For more details see <code>BeanUtilsBean</code>.</p> 392 * 393 * @param bean Bean whose property is to be extracted 394 * @param name Name of the property to be extracted 395 * @return The property's value, converted to a String 396 * 397 * @exception IllegalAccessException if the caller does not have 398 * access to the property accessor method 399 * @exception InvocationTargetException if the property accessor method 400 * throws an exception 401 * @exception NoSuchMethodException if an accessor method for this 402 * property cannot be found 403 * @see BeanUtilsBean#getSimpleProperty 404 */ 405 public static String getSimpleProperty(Object bean, String name) 406 throws IllegalAccessException, InvocationTargetException, 407 NoSuchMethodException { 408 409 return BeanUtilsBean.getInstance().getSimpleProperty(bean, name); 410 411 } 412 413 414 /** 415 * <p>Populate the JavaBeans properties of the specified bean, based on 416 * the specified name/value pairs.</p> 417 * 418 * <p>For more details see <code>BeanUtilsBean</code>.</p> 419 * 420 * @param bean JavaBean whose properties are being populated 421 * @param properties Map keyed by property name, with the 422 * corresponding (String or String[]) value(s) to be set 423 * 424 * @exception IllegalAccessException if the caller does not have 425 * access to the property accessor method 426 * @exception InvocationTargetException if the property accessor method 427 * throws an exception 428 * @see BeanUtilsBean#populate 429 */ 430 public static void populate(Object bean, Map properties) 431 throws IllegalAccessException, InvocationTargetException { 432 433 BeanUtilsBean.getInstance().populate(bean, properties); 434 } 435 436 437 /** 438 * <p>Set the specified property value, performing type conversions as 439 * required to conform to the type of the destination property.</p> 440 * 441 * <p>For more details see <code>BeanUtilsBean</code>.</p> 442 * 443 * @param bean Bean on which setting is to be performed 444 * @param name Property name (can be nested/indexed/mapped/combo) 445 * @param value Value to be set 446 * 447 * @exception IllegalAccessException if the caller does not have 448 * access to the property accessor method 449 * @exception InvocationTargetException if the property accessor method 450 * throws an exception 451 * @see BeanUtilsBean#setProperty 452 */ 453 public static void setProperty(Object bean, String name, Object value) 454 throws IllegalAccessException, InvocationTargetException { 455 456 BeanUtilsBean.getInstance().setProperty(bean, name, value); 457 } 458 459 /** 460 * If we're running on JDK 1.4 or later, initialize the cause for the given throwable. 461 * 462 * @param throwable The throwable. 463 * @param cause The cause of the throwable. 464 * @return true if the cause was initialized, otherwise false. 465 * @since 1.8.0 466 */ 467 public static boolean initCause(Throwable throwable, Throwable cause) { 468 return BeanUtilsBean.getInstance().initCause(throwable, cause); 469 } 470 471 /** 472 * Create a cache. 473 * @return a new cache 474 * @since 1.8.0 475 */ 476 public static Map createCache() { 477 return new WeakFastHashMap(); 478 } 479 480 /** 481 * Return whether a Map is fast 482 * @param map The map 483 * @return Whether it is fast or not. 484 * @since 1.8.0 485 */ 486 public static boolean getCacheFast(Map map) { 487 if (map instanceof WeakFastHashMap) { 488 return ((WeakFastHashMap)map).getFast(); 489 } else { 490 return false; 491 } 492 } 493 494 /** 495 * Set whether fast on a Map 496 * @param map The map 497 * @param fast Whether it should be fast or not. 498 * @since 1.8.0 499 */ 500 public static void setCacheFast(Map map, boolean fast) { 501 if (map instanceof WeakFastHashMap) { 502 ((WeakFastHashMap)map).setFast(fast); 503 } 504 } 505 }
You can do anything you set your mind to, man!
