一个好用的hibernate泛型dao
以前从springside2.0上搞下来的很好用的,基本实现dao零编码只要配置xml文件就行了。
先看图：
一共4层,com.demonstration.hibernate.basedao是我加的用来进一步解耦hibernate和spring的耦合。 原来的官方解释如下： SpringSide对Hibernate做了三层封装：
第一层：HibernateGenericDao，基于spring的HibernateDaoSupport，但加入了分页函数与各种Finder函数，并使用泛型避免了返回值强制类型转换。
第二层：HibernateEntityDao，基于HibernateGenericDao，用泛型声明Dao所管理的Entity类，默认拥有该entity的CRUD方法。
第三层：HibernateExtendDao，基于HibernateEntityDao，主要扩展各种选择性的功能。
关于三个类的详细注解请看JavaDoc，大致描述如下：
1 HibernateGenericDao 在Spring HibernateDaoSupport基础上封装的DAO，功能如下：
1.应用泛型:使得find(), get() 这些函数不再返回Object，而是返回T，不再需要强制类型转换。
2.提供各种finder的简便函数 应用了JDK5可变参数的hsql查询函数：List find(String hql, Object... values)，支持find(hql),find(hql, param1); find(hql,param1,param2);find(hql,new Object[] {param1,param2}) 四种接口。
简单查询的简化函数：findBy(Class entityClass,String name,Object value) ,findUniqueBy(Class entityClass,String name, Object value),findByLike(Class entityClass,String name,Object value)
3.获得设置好的Query和Criteria：createQuery(String hql,Object... values) 和 createCriteria(Class<T> entityClass,Criterion... criterions)
Spring并没有很好的接口封装支持firstResult, maxResult, fetchsize,cache,cacheRegion 等多个查询参数，所以springside宁愿返回已设置好查询条件的Query和Criteria，让大家继续剩下的参数设置，最后再执行 list()，注意那几个参数可以连续设置的，如：
createQuery(hql,param1).setFirstResult(10).setMaxResult(20).list(); 4.分页函数:Page pagedQuery(Criteria criteria, int pageNo, int pageSize) 和Page pagedQuery(String hql, int pageNo, int pageSize, Object... args)
Page是SpringSide自行封装的一个典型Page类，pagedQuery与hibernate自身分页查询的差别是先运行一次count，获得符合条件的总记录数。
如果查询不需要总记录数，用普通的hibernate API，加上setFirstResult(),setMaxResult()就解决，不需要pagedQuery()。
5.判别对象属性在数据库中唯一的函数:isUnique(Class<T> entityClass,Object entity,String names)。
2. HibernateEntityDao 所有UserManager, ProductManager之类只管理一类对象的Manager类的基类，只需要在类定义处声明Entity类型即可
public class BookManager extends HibernateEntityDao<Book> { } 通过<Book>的定义，避免了HibernateGenericDao类各方法中必有的Class entityClass参数。
如果需要操作其他的Entity，比如BookManager可能需要处理Category(图书目录)，可以注入CategoryManager。无需担心事务的问题，JavaEE的默认事务模型已能很好处理。
如果没有对应的CategoryManager，或者各种原因不想注入的话，可以使用BookManager继承自 HibernateGenericDao的带entityClass参数的函数来操作Category的增删改，如Category category= this.get(Category.class, 1);
3. HibernateExtendDao 此类演示SpringSide 所作的一些扩展，大家可以按照自己的需要进行修改和扩展。
1. 支持对象不能被直接删除，只能设置状态列为无效。 接口UndeleteableEntityOperation，定义了要支持此功能必须实现的函数。
可以有接口(UndeletableEntity)和annotation(@Undeletable)两种形式来定义无效列，annotation列形式还可以定义标识对象已删除的状态属性的名称，用接口则必须实现setStatus()接口，在里面操作实际的状态属性。
第四层就是把HibernateEntityDao和HibernateExtendDao以属性注入的方式注入到basedao,IBasedao就全局接口程序中使用的就是它，这个接口的实现全调用HibernateEntityDao和HibernateExtendDao的方法。方便以后的更改和替换，这样IBasedao接口不变就不要修改业务层的代码了。
代码如下(从下到上)：
1 Page.java 2 package com.demonstration.hibernate.dao.support; 3 import java.io.Serializable; 4 import java.util.ArrayList; 5 /** 6 * 分页对象. 包含当前页数据及分页信息如总记录数. 7 * 8 * @author springside 9 * 10 */ 11 @SuppressWarnings("serial") 12 public class Page implements Serializable { 13 private static int DEFAULT_PAGE_SIZE = 20; 14 private int pageSize = DEFAULT_PAGE_SIZE; // 每页的记录数 15 private long start; // 当前页第一条数据在List中的位置,从0开始 16 private Object data; // 当前页中存放的记录,类型一般为List 17 private long totalCount; // 总记录数 18 /** 19 * 构造方法，只构造空页. 20 */ 21 @SuppressWarnings("unchecked") 22 public Page() { 23 this(0, 0, DEFAULT_PAGE_SIZE, new ArrayList()); 24 } 25 /** 26 * 默认构造方法. 27 * 28 * @param start 本页数据在数据库中的起始位置 29 * @param totalSize 数据库中总记录条数 30 * @param pageSize 本页容量 31 * @param data 本页包含的数据 32 */ 33 public Page(long start, long totalSize, int pageSize, Object data) { 34 this.pageSize = pageSize; 35 this.start = start; 36 this.totalCount = totalSize; 37 this.data = data; 38 } 39 /** 40 * 取总记录数. 41 */ 42 public long getTotalCount() { 43 return this.totalCount; 44 } 45 /** 46 * 取总页数. 47 */ 48 public long getTotalPageCount() { 49 if (totalCount % pageSize == 0) 50 return totalCount / pageSize; 51 else 52 return totalCount / pageSize + 1; 53 } 54 /** 55 * 取每页数据容量. 56 */ 57 public int getPageSize() { 58 return pageSize; 59 } 60 /** 61 * 取当前页中的记录. 62 */ 63 public Object getResult() { 64 return data; 65 } 66 /** 67 * 取该页当前页码,页码从1开始. 68 */ 69 public long getCurrentPageNo() { 70 return start / pageSize + 1; 71 } 72 /** 73 * 该页是否有下一页. 74 */ 75 public boolean hasNextPage() { 76 return this.getCurrentPageNo() < this.getTotalPageCount() - 1; 77 } 78 /** 79 * 该页是否有上一页. 80 */ 81 public boolean hasPreviousPage() { 82 return this.getCurrentPageNo() > 1; 83 } 84 /** 85 * 获取任一页第一条数据在数据集的位置，每页条数使用默认值. 86 * 87 * @see #getStartOfPage(int,int) 88 */ 89 protected static int getStartOfPage(int pageNo) { 90 return getStartOfPage(pageNo, DEFAULT_PAGE_SIZE); 91 } 92 /** 93 * 获取任一页第一条数据在数据集的位置. 94 * 95 * @param pageNo 从1开始的页号 96 * @param pageSize 每页记录条数 97 * @return 该页第一条数据 98 */ 99 public static int getStartOfPage(int pageNo, int pageSize) { 100 return (pageNo - 1) * pageSize; 101 } 102 } 103 GenericsUtils.java 104 package com.demonstration.hibernate.dao.support; 105 import java.lang.reflect.ParameterizedType; 106 import java.lang.reflect.Type; 107 import org.apache.commons.logging.Log; 108 import org.apache.commons.logging.LogFactory; 109 /** 110 * Generics的util类. 111 * 112 * @author springside 113 * 114 */ 115 public class GenericsUtils { 116 private static final Log log = LogFactory.getLog(GenericsUtils.class); 117 private GenericsUtils() { 118 } 119 /** 120 * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends GenricManager<Book> 121 * 122 * @param clazz The class to introspect 123 * @return the first generic declaration, or <code>Object.class</code> if cannot be determined 124 */ 125 @SuppressWarnings("unchecked") 126 public static Class getSuperClassGenricType(Class clazz) { 127 return getSuperClassGenricType(clazz, 0); 128 } 129 /** 130 * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends GenricManager<Book> 131 * 132 * @param clazz clazz The class to introspect 133 * @param index the Index of the generic ddeclaration,start from 0. 134 * @return the index generic declaration, or <code>Object.class</code> if cannot be determined 135 */ 136 @SuppressWarnings("unchecked") 137 public static Class getSuperClassGenricType(Class clazz, int index) { 138 Type genType = clazz.getGenericSuperclass(); 139 if (!(genType instanceof ParameterizedType)) { 140 log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType"); 141 return Object.class; 142 } 143 Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); 144 if (index >= params.length || index < 0) { 145 log.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " 146 + params.length); 147 return Object.class; 148 } 149 if (!(params[index] instanceof Class)) { 150 log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter"); 151 return Object.class; 152 } 153 return (Class) params[index]; 154 } 155 } 156 157 158 BeanUtils.java 159 160 package com.demonstration.hibernate.dao.support; 161 import java.lang.reflect.Field; 162 import java.lang.reflect.Method; 163 import java.util.ArrayList; 164 import java.util.List; 165 import org.apache.commons.lang.StringUtils; 166 import org.apache.commons.logging.Log; 167 import org.apache.commons.logging.LogFactory; 168 import org.springframework.util.Assert; 169 import org.springframework.util.ReflectionUtils; 170 /** 171 * 扩展Apache Commons BeanUtils, 提供一些反射方面缺失功能的封装. 172 * @author springside 173 * 174 */ 175 public class BeanUtils extends org.apache.commons.beanutils.BeanUtils { 176 protected static final Log logger = LogFactory.getLog(BeanUtils.class); 177 private BeanUtils() { 178 } 179 /** 180 * 循环向上转型,获取对象的DeclaredField. 181 * 182 * @throws NoSuchFieldException 如果没有该Field时抛出. 183 */ 184 public static Field getDeclaredField(Object object, String propertyName) throws NoSuchFieldException { 185 Assert.notNull(object); 186 Assert.hasText(propertyName); 187 return getDeclaredField(object.getClass(), propertyName); 188 } 189 /** 190 * 循环向上转型,获取对象的DeclaredField. 191 * 192 * @throws NoSuchFieldException 如果没有该Field时抛出. 193 */ 194 @SuppressWarnings("unchecked") 195 public static Field getDeclaredField(Class clazz, String propertyName) throws NoSuchFieldException { 196 Assert.notNull(clazz); 197 Assert.hasText(propertyName); 198 for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) { 199 try { 200 return superClass.getDeclaredField(propertyName); 201 } catch (NoSuchFieldException e) { 202 // Field不在当前类定义,继续向上转型 203 } 204 } 205 throw new NoSuchFieldException("No such field: " + clazz.getName() + '.' + propertyName); 206 } 207 /** 208 * 暴力获取对象变量值,忽略private,protected修饰符的限制. 209 * 210 * @throws NoSuchFieldException 如果没有该Field时抛出. 211 */ 212 public static Object forceGetProperty(Object object, String propertyName) throws NoSuchFieldException { 213 Assert.notNull(object); 214 Assert.hasText(propertyName); 215 Field field = getDeclaredField(object, propertyName); 216 boolean accessible = field.isAccessible(); 217 field.setAccessible(true); 218 Object result = null; 219 try { 220 result = field.get(object); 221 } catch (IllegalAccessException e) { 222 logger.info("error wont' happen"); 223 } 224 field.setAccessible(accessible); 225 return result; 226 } 227 /** 228 * 暴力设置对象变量值,忽略private,protected修饰符的限制. 229 * 230 * @throws NoSuchFieldException 如果没有该Field时抛出. 231 */ 232 public static void forceSetProperty(Object object, String propertyName, Object newValue) 233 throws NoSuchFieldException { 234 Assert.notNull(object); 235 Assert.hasText(propertyName); 236 Field field = getDeclaredField(object, propertyName); 237 boolean accessible = field.isAccessible(); 238 field.setAccessible(true); 239 try { 240 field.set(object, newValue); 241 } catch (IllegalAccessException e) { 242 logger.info("Error won't happen"); 243 } 244 field.setAccessible(accessible); 245 } 246 /** 247 * 暴力调用对象函数,忽略private,protected修饰符的限制. 248 * 249 * @throws NoSuchMethodException 如果没有该Method时抛出. 250 */ 251 @SuppressWarnings("unchecked") 252 public static Object invokePrivateMethod(Object object, String methodName, Object... params) 253 throws NoSuchMethodException { 254 Assert.notNull(object); 255 Assert.hasText(methodName); 256 Class[] types = new Class[params.length]; 257 for (int i = 0; i < params.length; i++) { 258 types[i] = params[i].getClass(); 259 } 260 Class clazz = object.getClass(); 261 Method method = null; 262 for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) { 263 try { 264 method = superClass.getDeclaredMethod(methodName, types); 265 break; 266 } catch (NoSuchMethodException e) { 267 // 方法不在当前类定义,继续向上转型 268 } 269 } 270 if (method == null) 271 throw new NoSuchMethodException("No Such Method:" + clazz.getSimpleName() + methodName); 272 boolean accessible = method.isAccessible(); 273 method.setAccessible(true); 274 Object result = null; 275 try { 276 result = method.invoke(object, params); 277 } catch (Exception e) { 278 ReflectionUtils.handleReflectionException(e); 279 } 280 method.setAccessible(accessible); 281 return result; 282 } 283 /** 284 * 按Filed的类型取得Field列表. 285 */ 286 @SuppressWarnings("unchecked") 287 public static List<Field> getFieldsByType(Object object, Class type) { 288 List<Field> list = new ArrayList<Field>(); 289 Field[] fields = object.getClass().getDeclaredFields(); 290 for (Field field : fields) { 291 if (field.getType().isAssignableFrom(type)) { 292 list.add(field); 293 } 294 } 295 return list; 296 } 297 /** 298 * 按FiledName获得Field的类型. 299 */ 300 @SuppressWarnings("unchecked") 301 public static Class getPropertyType(Class type, String name) throws NoSuchFieldException { 302 return getDeclaredField(type, name).getType(); 303 } 304 /** 305 * 获得field的getter函数名称. 306 */ 307 @SuppressWarnings("unchecked") 308 public static String getGetterName(Class type, String fieldName) { 309 Assert.notNull(type, "Type required"); 310 Assert.hasText(fieldName, "FieldName required"); 311 if (type.getName().equals("boolean")) { 312 return "is" + StringUtils.capitalize(fieldName); 313 } else { 314 return "get" + StringUtils.capitalize(fieldName); 315 } 316 } 317 /** 318 * 获得field的getter函数,如果找不到该方法,返回null. 319 */ 320 @SuppressWarnings("unchecked") 321 public static Method getGetterMethod(Class type, String fieldName) { 322 try { 323 return type.getMethod(getGetterName(type, fieldName)); 324 } catch (NoSuchMethodException e) { 325 logger.error(e.getMessage(), e); 326 } 327 return null; 328 } 329 } 330 331 332 IUndeleteableEntityOperation.java 333 334 package com.demonstration.hibernate.dao.extend; 335 import java.util.List; 336 import org.hibernate.criterion.Criterion; 337 /** 338 * 定义如果支持Entity不被直接删除必须支持的Operation. 339 * 340 * @author springside 341 * 342 */ 343 public interface IUndeleteableEntityOperation<T> { 344 /* 345 * Undelete Entity用到的几个常量,因为要同时兼顾Interface与Annotation,所以集中放此. 346 */ 347 String UNVALID_VALUE = "-1"; 348 String NORMAL_VALUE = "0"; 349 String STATUS = "status"; 350 /** 351 * 取得所有状态为有效的对象. 352 */ 353 List<T> getAllValid(); 354 /** 355 * 删除对象，但如果是Undeleteable的entity,设置对象的状态而不是直接删除. 356 */ 357 void remove(Object entity); 358 /** 359 * 获取过滤已删除对象的hql条件语句. 360 */ 361 String getUnDeletableHQL(); 362 /** 363 * 获取过滤已删除对象的Criterion条件语句. 364 */ 365 Criterion getUnDeletableCriterion(); 366 } 367 368 IUndeletableEntity.java 369 package com.demonstration.hibernate.dao.extend; 370 /** 371 * 标识商业对象不能被删除,只能被设为无效的接口. 372 * 373 * @author springside 374 * 375 */ 376 public interface IUndeletableEntity { 377 void setStatus(String status); 378 } 379 380 IUndeletable.java 381 package com.demonstration.hibernate.dao.extend; 382 import java.lang.annotation.ElementType; 383 import java.lang.annotation.Retention; 384 import java.lang.annotation.RetentionPolicy; 385 import java.lang.annotation.Target; 386 /** 387 * 标识商业对象不能被删除,只能被设为无效的Annoation. 388 * <p/> 389 * 相比inferface的标示方式，annotation 方式更少侵入性,可以定义任意属性代表status,而默认为status属性. 390 */ 391 @Target({ElementType.TYPE}) 392 @Retention(RetentionPolicy.RUNTIME) 393 public @interface IUndeletable { 394 String status() default IUndeleteableEntityOperation.STATUS; 395 } 396 397 HibernateEntityExtendDao.java 398 package com.demonstration.hibernate.dao.extend; 399 import java.util.List; 400 import java.util.Map; 401 import org.apache.commons.beanutils.PropertyUtils; 402 import org.hibernate.Criteria; 403 import org.hibernate.criterion.Criterion; 404 import org.hibernate.criterion.Restrictions; 405 import org.springframework.util.Assert; 406 import org.springframework.util.ReflectionUtils; 407 import com.demonstration.hibernate.dao.HibernateEntityDao; 408 409 /** 410 * 加强版的entity dao. 411 * <p>自动处理Undeletable Entity.<br> 412 * Undeletable Entity 在删除时只把状态设为无效,不会真正执行删除.<br> 413 * Undeletable Entity 可以通过annotation或接口两种形式来声明.<br> 414 * 其中annotation模式不限制状态列的属性名必须为"status",可以用注释来确定任意属性为状态属性.<br> 415 * </p> 416 * 417 * @author springside 418 * 419 * @see HibernateEntityDao 420 * @see EntityInfo 421 * @see IUndeleteableEntityOperation 422 * @see IUndeletable 423 * @see IUndeletableEntity 424 */ 425 @SuppressWarnings("unchecked") 426 public class HibernateEntityExtendDao<T> extends HibernateEntityDao<T> implements IUndeleteableEntityOperation<T> { 427 /** 428 * 保存所管理的Entity的信息. 429 */ 430 protected EntityInfo entityInfo; 431 /** 432 * 构造函数，初始化entity信息. 433 */ 434 public HibernateEntityExtendDao() { 435 entityInfo = new EntityInfo(entityClass); 436 } 437 /** 438 * 取得所有状态为有效的对象. 439 * 440 * @see IUndeleteableEntityOperation#getAllValid() 441 */ 442 public List<T> getAllValid() { 443 Criteria criteria = createCriteria(); 444 if (entityInfo.isUndeletable) 445 criteria.add(getUnDeletableCriterion()); 446 return criteria.list(); 447 } 448 /** 449 * 获取过滤已删除对象的hql条件语句. 450 * 451 * @see IUndeleteableEntityOperation#getUnDeletableHQL() 452 */ 453 public String getUnDeletableHQL() { 454 return entityInfo.statusProperty + "<>" + UNVALID_VALUE; 455 } 456 /** 457 * 获取过滤已删除对象的Criterion条件语句. 458 * 459 * @see UndeleteableEntityOperation# 460 */ 461 public Criterion getUnDeletableCriterion() { 462 return Restrictions.not(Restrictions.eq(entityInfo.statusProperty, UNVALID_VALUE)); 463 } 464 /** 465 * 重载保存函数,在保存前先调用onValid(T),进行书名不重复等数据库相关的校验. 466 * 467 * @see #onValid(Object) 468 * @see HibernateEntityDao#save(Object) 469 */ 470 @Override 471 public void save(Object entity) { 472 Assert.isInstanceOf(getEntityClass(), entity); 473 onValid((T) entity); 474 super.save(entity); 475 } 476 /** 477 * 删除对象，如果是Undeleteable的entity,设置对象的状态而不是直接删除. 478 * 479 * @see HibernateEntityDao#remove(Object) 480 */ 481 @Override 482 public void remove(Object entity) { 483 if (entityInfo.isUndeletable) { 484 try { 485 PropertyUtils.setProperty(entity, entityInfo.statusProperty, UNVALID_VALUE); 486 save(entity); 487 } catch (Exception e) { 488 ReflectionUtils.handleReflectionException(e); 489 } 490 } else 491 super.remove(entity); 492 } 493 /** 494 * 与数据库相关的校验,比如判断名字在数据库里有没有重复, 在保存时被调用,在子类重载. 495 * 496 * @see #save(Object) 497 */ 498 public void onValid(T entity) { 499 } 500 /** 501 * 根据Map中的条件的Criteria查询. 502 * 503 * @param map Map中仅包含条件名与条件值，默认全部相同,可重载。 504 */ 505 public List<T> find(Map map) { 506 Criteria criteria = createCriteria(); 507 return find(criteria, map); 508 } 509 /** 510 * 根据Map中的条件的Criteria查询. 511 * 512 * @param map Map中仅包含条件名与条件值,默认全部相同,可重载. 513 */ 514 public List<T> find(Criteria criteria, Map map) { 515 Assert.notNull(criteria); 516 criteria.add(Restrictions.allEq(map)); 517 return criteria.list(); 518 } 519 } 520 521 522 EntityInfo.java 523 package com.demonstration.hibernate.dao.extend; 524 /** 525 * 装载Entity信息的内部类. 526 * 527 * @author springside 528 * 529 */ 530 class EntityInfo { 531 boolean isUndeletable = false; // entity是否undeleteable的标志 532 String statusProperty; // 标识状态的属性名 533 @SuppressWarnings("unchecked") 534 public EntityInfo(Class entityClass) { 535 init(entityClass); 536 } 537 /** 538 * 初始函数,判断EntityClass是否UndeletableEntity. 539 */ 540 @SuppressWarnings("unchecked") 541 private void init(Class entityClass) { 542 // 通过EntityClass的interface判断entity是否undeletable 543 if (IUndeletableEntity.class.isAssignableFrom(entityClass)) { 544 isUndeletable = true; 545 statusProperty = IUndeleteableEntityOperation.STATUS; 546 } 547 // 通过EntityClass的annotation判断entity是否undeletable 548 if (entityClass.isAnnotationPresent(IUndeletable.class)) { 549 isUndeletable = true; 550 IUndeletable anno = (IUndeletable) entityClass.getAnnotation(IUndeletable.class); 551 statusProperty = anno.status(); 552 } 553 } 554 } 555 556 IEntityDao.java 557 package com.demonstration.hibernate.dao; 558 import java.io.Serializable; 559 import java.util.List; 560 /** 561 * 针对单个Entity对象的操作定义.不依赖于具体ORM实现方案. 562 * 563 * @author springside 564 * 565 */ 566 public interface IEntityDao<T> { 567 T get(Serializable id); 568 List<T> getAll(); 569 void save(Object o); 570 void remove(Object o); 571 void removeById(Serializable id); 572 /** 573 * 获取Entity对象的主键名. 574 */ 575 @SuppressWarnings("unchecked") 576 String getIdName(Class clazz); 577 } 578 579 HibernateGenericDao.java 580 package com.demonstration.hibernate.dao; 581 import java.io.Serializable; 582 import java.lang.reflect.InvocationTargetException; 583 import java.util.ArrayList; 584 import java.util.List; 585 import java.util.regex.Matcher; 586 import java.util.regex.Pattern; 587 import org.apache.commons.beanutils.PropertyUtils; 588 import org.hibernate.Criteria; 589 import org.hibernate.Query; 590 import org.hibernate.criterion.CriteriaSpecification; 591 import org.hibernate.criterion.Criterion; 592 import org.hibernate.criterion.DetachedCriteria; 593 import org.hibernate.criterion.Order; 594 import org.hibernate.criterion.Projection; 595 import org.hibernate.criterion.Projections; 596 import org.hibernate.criterion.Restrictions; 597 import org.hibernate.impl.CriteriaImpl; 598 import org.hibernate.metadata.ClassMetadata; 599 import org.springframework.orm.hibernate3.support.HibernateDaoSupport; 600 import org.springframework.util.Assert; 601 import org.springframework.util.ReflectionUtils; 602 import com.demonstration.hibernate.dao.support.BeanUtils; 603 import com.demonstration.hibernate.dao.support.Page; 604 605 /** 606 * Hibernate Dao的泛型基类. 607 * <p/> 608 * 继承于Spring的<code>HibernateDaoSupport</code>,提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换. 609 * 610 * @author springside 611 * 612 * @see HibernateDaoSupport 613 * @see HibernateEntityDao 614 */ 615 @SuppressWarnings("unchecked") 616 public class HibernateGenericDao extends HibernateDaoSupport { 617 /** 618 * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常. 619 */ 620 public <T> T get(Class<T> entityClass, Serializable id) { 621 return (T) getHibernateTemplate().load(entityClass, id); 622 } 623 /** 624 * 获取全部对象. 625 */ 626 public <T> List<T> getAll(Class<T> entityClass) { 627 return getHibernateTemplate().loadAll(entityClass); 628 } 629 /** 630 * 获取全部对象,带排序字段与升降序参数. 631 */ 632 public <T> List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc) { 633 Assert.hasText(orderBy); 634 if (isAsc) 635 return getHibernateTemplate().findByCriteria( 636 DetachedCriteria.forClass(entityClass).addOrder(Order.asc(orderBy))); 637 else 638 return getHibernateTemplate().findByCriteria( 639 DetachedCriteria.forClass(entityClass).addOrder(Order.desc(orderBy))); 640 } 641 /** 642 * 保存对象. 643 */ 644 public void save(Object o) { 645 getHibernateTemplate().saveOrUpdate(o); 646 } 647 /** 648 * 删除对象. 649 */ 650 public void remove(Object o) { 651 getHibernateTemplate().delete(o); 652 } 653 /** 654 * 根据ID删除对象. 655 */ 656 public <T> void removeById(Class<T> entityClass, Serializable id) { 657 remove(get(entityClass, id)); 658 } 659 public void flush() { 660 getHibernateTemplate().flush(); 661 } 662 public void clear() { 663 getHibernateTemplate().clear(); 664 } 665 /** 666 * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置. 667 * 留意可以连续设置,如下： 668 * <pre> 669 * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list(); 670 * </pre> 671 * 调用方式如下： 672 * <pre> 673 * dao.createQuery(hql) 674 * dao.createQuery(hql,arg0); 675 * dao.createQuery(hql,arg0,arg1); 676 * dao.createQuery(hql,new Object[arg0,arg1,arg2]) 677 * </pre> 678 * 679 * @param values 可变参数. 680 */ 681 public Query createQuery(String hql, Object... values) { 682 Assert.hasText(hql); 683 Query query = getSession().createQuery(hql); 684 for (int i = 0; i < values.length; i++) { 685 query.setParameter(i, values[i]); 686 } 687 return query; 688 } 689 /** 690 * 创建Criteria对象. 691 * 692 * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)} 693 */ 694 public <T> Criteria createCriteria(Class<T> entityClass, Criterion... criterions) { 695 Criteria criteria = getSession().createCriteria(entityClass); 696 for (Criterion c : criterions) { 697 criteria.add(c); 698 } 699 return criteria; 700 } 701 /** 702 * 创建Criteria对象，带排序字段与升降序字段. 703 * 704 * @see #createCriteria(Class,Criterion[]) 705 */ 706 public <T> Criteria createCriteria(Class<T> entityClass, String orderBy, boolean isAsc, Criterion... criterions) { 707 Assert.hasText(orderBy); 708 Criteria criteria = createCriteria(entityClass, criterions); 709 if (isAsc) 710 criteria.addOrder(Order.asc(orderBy)); 711 else 712 criteria.addOrder(Order.desc(orderBy)); 713 return criteria; 714 } 715 /** 716 * 根据hql查询,直接使用HibernateTemplate的find函数. 717 * 718 * @param values 可变参数,见{@link #createQuery(String,Object...)} 719 */ 720 public List find(String hql, Object... values) { 721 Assert.hasText(hql); 722 return getHibernateTemplate().find(hql, values); 723 } 724 /** 725 * 根据属性名和属性值查询对象. 726 * 727 * @return 符合条件的对象列表 728 */ 729 public <T> List<T> findBy(Class<T> entityClass, String propertyName, Object value) { 730 Assert.hasText(propertyName); 731 return createCriteria(entityClass, Restrictions.eq(propertyName, value)).list(); 732 } 733 /** 734 * 根据属性名和属性值查询对象,带排序参数. 735 */ 736 public <T> List<T> findBy(Class<T> entityClass, String propertyName, Object value, String orderBy, boolean isAsc) { 737 Assert.hasText(propertyName); 738 Assert.hasText(orderBy); 739 return createCriteria(entityClass, orderBy, isAsc, Restrictions.eq(propertyName, value)).list(); 740 } 741 /** 742 * 根据属性名和属性值查询唯一对象. 743 * 744 * @return 符合条件的唯一对象 or null if not found. 745 */ 746 public <T> T findUniqueBy(Class<T> entityClass, String propertyName, Object value) { 747 Assert.hasText(propertyName); 748 return (T) createCriteria(entityClass, Restrictions.eq(propertyName, value)).uniqueResult(); 749 } 750 /** 751 * 分页查询函数，使用hql. 752 * 753 * @param pageNo 页号,从1开始. 754 */ 755 public Page pagedQuery(String hql, int pageNo, int pageSize, Object... values) { 756 Assert.hasText(hql); 757 Assert.isTrue(pageNo >= 1, "pageNo should start from 1"); 758 // Count查询 759 String countQueryString = " select count (*) " + removeSelect(removeOrders(hql)); 760 List countlist = getHibernateTemplate().find(countQueryString, values); 761 long totalCount = (Long) countlist.get(0); 762 if (totalCount < 1) 763 return new Page(); 764 // 实际查询返回分页对象 765 int startIndex = Page.getStartOfPage(pageNo, pageSize); 766 Query query = createQuery(hql, values); 767 List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list(); 768 return new Page(startIndex, totalCount, pageSize, list); 769 } 770 771 /** 772 * @author Scott.wanglei 773 * @since 2008-7-21 774 * @param hql 查询sql 775 * @param start 分页从哪一条数据开始 776 * @param pageSize 每一个页面的大小 777 * @param values 查询条件 778 * @return page对象 779 */ 780 public Page dataQuery(String hql, int start, int pageSize, Object... values){ 781 // Count查询 782 String countQueryString = " select count (*) " + removeSelect(removeOrders(hql)); 783 List countlist = getHibernateTemplate().find(countQueryString, values); 784 long totalCount = (Long) countlist.get(0); 785 if (totalCount < 1) 786 return new Page(); 787 // 实际查询返回分页对象 788 int startIndex = start; 789 Query query = createQuery(hql, values); 790 List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list(); 791 return new Page(startIndex, totalCount, pageSize, list); 792 } 793 /** 794 * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>. 795 * 796 * @param pageNo 页号,从1开始. 797 * @return 含总记录数和当前页数据的Page对象. 798 */ 799 public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) { 800 Assert.notNull(criteria); 801 Assert.isTrue(pageNo >= 1, "pageNo should start from 1"); 802 CriteriaImpl impl = (CriteriaImpl) criteria; 803 // 先把Projection和OrderBy条件取出来,清空两者来执行Count操作 804 Projection projection = impl.getProjection(); 805 List<CriteriaImpl.OrderEntry> orderEntries; 806 try { 807 orderEntries = (List) BeanUtils.forceGetProperty(impl, "orderEntries"); 808 BeanUtils.forceSetProperty(impl, "orderEntries", new ArrayList()); 809 } catch (Exception e) { 810 throw new InternalError(" Runtime Exception impossibility throw "); 811 } 812 // 执行查询 813 int totalCount = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult(); 814 // 将之前的Projection和OrderBy条件重新设回去 815 criteria.setProjection(projection); 816 if (projection == null) { 817 criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY); 818 } 819 try { 820 BeanUtils.forceSetProperty(impl, "orderEntries", orderEntries); 821 } catch (Exception e) { 822 throw new InternalError(" Runtime Exception impossibility throw "); 823 } 824 // 返回分页对象 825 if (totalCount < 1) 826 return new Page(); 827 int startIndex = Page.getStartOfPage(pageNo, pageSize);; 828 List list = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list(); 829 return new Page(startIndex, totalCount, pageSize, list); 830 } 831 /** 832 * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>. 833 * 834 * @param pageNo 页号,从1开始. 835 * @return 含总记录数和当前页数据的Page对象. 836 */ 837 public Page pagedQuery(Class entityClass, int pageNo, int pageSize, Criterion... criterions) { 838 Criteria criteria = createCriteria(entityClass, criterions); 839 return pagedQuery(criteria, pageNo, pageSize); 840 } 841 /** 842 * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>. 843 * 844 * @param pageNo 页号,从1开始. 845 * @return 含总记录数和当前页数据的Page对象. 846 */ 847 public Page pagedQuery(Class entityClass, int pageNo, int pageSize, String orderBy, boolean isAsc, 848 Criterion... criterions) { 849 Criteria criteria = createCriteria(entityClass, orderBy, isAsc, criterions); 850 return pagedQuery(criteria, pageNo, pageSize); 851 } 852 /** 853 * 判断对象某些属性的值在数据库中是否唯一. 854 * 855 * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" 856 */ 857 public <T> boolean isUnique(Class<T> entityClass, Object entity, String uniquePropertyNames) { 858 Assert.hasText(uniquePropertyNames); 859 Criteria criteria = createCriteria(entityClass).setProjection(Projections.rowCount()); 860 String[] nameList = uniquePropertyNames.split(","); 861 try { 862 // 循环加入唯一列 863 for (String name : nameList) { 864 criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(entity, name))); 865 } 866 // 以下代码为了如果是update的情况,排除entity自身. 867 String idName = getIdName(entityClass); 868 // 取得entity的主键值 869 Serializable id = getId(entityClass, entity); 870 // 如果id!=null,说明对象已存在,该操作为update,加入排除自身的判断 871 if (id != null) 872 criteria.add(Restrictions.not(Restrictions.eq(idName, id))); 873 } catch (Exception e) { 874 ReflectionUtils.handleReflectionException(e); 875 } 876 return (Integer) criteria.uniqueResult() == 0; 877 } 878 /** 879 * 取得对象的主键值,辅助函数. 880 */ 881 public Serializable getId(Class entityClass, Object entity) throws NoSuchMethodException, IllegalAccessException, 882 InvocationTargetException { 883 Assert.notNull(entity); 884 Assert.notNull(entityClass); 885 return (Serializable) PropertyUtils.getProperty(entity, getIdName(entityClass)); 886 } 887 /** 888 * 取得对象的主键名,辅助函数. 889 */ 890 public String getIdName(Class clazz) { 891 Assert.notNull(clazz); 892 ClassMetadata meta = getSessionFactory().getClassMetadata(clazz); 893 Assert.notNull(meta, "Class " + clazz + " not define in hibernate session factory."); 894 String idName = meta.getIdentifierPropertyName(); 895 Assert.hasText(idName, clazz.getSimpleName() + " has no identifier property define."); 896 return idName; 897 } 898 /** 899 * 去除hql的select 子句，未考虑union的情况,用于pagedQuery. 900 * 901 * @see #pagedQuery(String,int,int,Object[]) 902 */ 903 private static String removeSelect(String hql) { 904 Assert.hasText(hql); 905 int beginPos = hql.toLowerCase().indexOf("from"); 906 Assert.isTrue(beginPos != -1, " hql : " + hql + " must has a keyword 'from'"); 907 return hql.substring(beginPos); 908 } 909 /** 910 * 去除hql的orderby 子句，用于pagedQuery. 911 * 912 * @see #pagedQuery(String,int,int,Object[]) 913 */ 914 private static String removeOrders(String hql) { 915 Assert.hasText(hql); 916 Pattern p = Pattern.compile("order//s*by[//w|//W|//s|//S]*", Pattern.CASE_INSENSITIVE); 917 Matcher m = p.matcher(hql); 918 StringBuffer sb = new StringBuffer(); 919 while (m.find()) { 920 m.appendReplacement(sb, ""); 921 } 922 m.appendTail(sb); 923 return sb.toString(); 924 } 925 926 } 927 HibernateEntityDao.java 928 package com.demonstration.hibernate.dao; 929 import java.io.Serializable; 930 import java.util.List; 931 import org.hibernate.Criteria; 932 import org.hibernate.criterion.Criterion; 933 import com.demonstration.hibernate.dao.support.GenericsUtils; 934 /** 935 * 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类. <p/> 子类只要在类定义时指定所管理Entity的Class, 936 * 即拥有对单个Entity对象的CRUD操作. 937 * 938 * <pre> 939 * public class UserManager extends HibernateEntityDao<User> { 940 * } 941 * </pre> 942 * 943 * @author springside 944 * 945 * @see HibernateGenericDao 946 */ 947 @SuppressWarnings("unchecked") 948 public class HibernateEntityDao<T> extends HibernateGenericDao implements 949 IEntityDao<T> { 950 protected Class<T> entityClass;// DAO所管理的Entity类型. 951 /** 952 * 在构造函数中将泛型T.class赋给entityClass. 953 */ 954 public HibernateEntityDao() { 955 entityClass = GenericsUtils.getSuperClassGenricType(getClass()); 956 } 957 /** 958 * 重载构造函数 让spring提供构造函数注入 959 */ 960 public HibernateEntityDao(Class<T> type) { 961 this.entityClass = type; 962 } 963 964 /** 965 * 取得entityClass.JDK1.4不支持泛型的子类可以抛开Class<T> entityClass,重载此函数达到相同效果。 966 */ 967 protected Class<T> getEntityClass() { 968 return entityClass; 969 } 970 971 public void setEntityClass(Class<T> type){ 972 this.entityClass=type; 973 } 974 /** 975 * 根据ID获取对象. 976 * 977 * @see HibernateGenericDao#getId(Class,Object) 978 */ 979 public T get(Serializable id) { 980 return get(getEntityClass(), id); 981 } 982 /** 983 * 获取全部对象 984 * 985 * @see HibernateGenericDao#getAll(Class) 986 */ 987 public List<T> getAll() { 988 return getAll(getEntityClass()); 989 } 990 /** 991 * 获取全部对象,带排序参数. 992 * 993 * @see HibernateGenericDao#getAll(Class,String,boolean) 994 */ 995 public List<T> getAll(String orderBy, boolean isAsc) { 996 return getAll(getEntityClass(), orderBy, isAsc); 997 } 998 /** 999 * 根据ID移除对象. 1000 * 1001 * @see HibernateGenericDao#removeById(Class,Serializable) 1002 */ 1003 public void removeById(Serializable id) { 1004 removeById(getEntityClass(), id); 1005 } 1006 /** 1007 * 取得Entity的Criteria. 1008 * 1009 * @see HibernateGenericDao#createCriteria(Class,Criterion[]) 1010 */ 1011 public Criteria createCriteria(Criterion... criterions) { 1012 return createCriteria(getEntityClass(), criterions); 1013 } 1014 /** 1015 * 取得Entity的Criteria,带排序参数. 1016 * 1017 * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[]) 1018 */ 1019 public Criteria createCriteria(String orderBy, boolean isAsc, 1020 Criterion... criterions) { 1021 return createCriteria(getEntityClass(), orderBy, isAsc, criterions); 1022 } 1023 /** 1024 * 根据属性名和属性值查询对象. 1025 * 1026 * @return 符合条件的对象列表 1027 * @see HibernateGenericDao#findBy(Class,String,Object) 1028 */ 1029 public List<T> findBy(String propertyName, Object value) { 1030 return findBy(getEntityClass(), propertyName, value); 1031 } 1032 /** 1033 * 根据属性名和属性值查询对象,带排序参数. 1034 * 1035 * @return 符合条件的对象列表 1036 * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean) 1037 */ 1038 public List<T> findBy(String propertyName, Object value, String orderBy, 1039 boolean isAsc) { 1040 return findBy(getEntityClass(), propertyName, value, orderBy, isAsc); 1041 } 1042 /** 1043 * 根据属性名和属性值查询单个对象. 1044 * 1045 * @return 符合条件的唯一对象 or null 1046 * @see HibernateGenericDao#findUniqueBy(Class,String,Object) 1047 */ 1048 public T findUniqueBy(String propertyName, Object value) { 1049 return findUniqueBy(getEntityClass(), propertyName, value); 1050 } 1051 /** 1052 * 判断对象某些属性的值在数据库中唯一. 1053 * 1054 * @param uniquePropertyNames 1055 * 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" 1056 * @see HibernateGenericDao#isUnique(Class,Object,String) 1057 */ 1058 public boolean isUnique(Object entity, String uniquePropertyNames) { 1059 return isUnique(getEntityClass(), entity, uniquePropertyNames); 1060 } 1061 /** 1062 * 消除与 Hibernate Session 的关联 1063 * 1064 * @param entity 1065 */ 1066 public void evit(Object entity) { 1067 getHibernateTemplate().evict(entity); 1068 } 1069 } 1070 1071 IBaseDao.java 1072 /** 1073 * 1074 */ 1075 package com.demonstration.hibernate.basedao; 1076 import java.io.Serializable; 1077 import java.lang.reflect.InvocationTargetException; 1078 import java.util.List; 1079 import java.util.Map; 1080 import org.hibernate.Criteria; 1081 import org.hibernate.Query; 1082 import org.hibernate.criterion.Criterion; 1083 import com.demonstration.hibernate.dao.HibernateEntityDao; 1084 import com.demonstration.hibernate.dao.HibernateGenericDao; 1085 import com.demonstration.hibernate.dao.extend.IUndeleteableEntityOperation; 1086 import com.demonstration.hibernate.dao.support.Page; 1087 1088 /** 1089 * @author 1090 * 1091 * 提供hibernate dao的所有操作, 1092 * 实现类由spring注入HibernateEntityDao和HibernateEntityExtendDao来实现 1093 * 最大限度的解耦hibernate持久层的操作 1094 */ 1095 public interface IBaseDao<T> { 1096 /** 1097 * 根据ID获取对象. 1098 * 1099 * @see HibernateGenericDao#getId(Class,Object) 1100 */ 1101 public T get(Serializable id); 1102 1103 /** 1104 * 获取全部对象 1105 * 1106 * @see HibernateGenericDao#getAll(Class) 1107 */ 1108 public List<T> getAll(); 1109 1110 /** 1111 * 获取全部对象,带排序参数. 1112 * 1113 * @see HibernateGenericDao#getAll(Class,String,boolean) 1114 */ 1115 public List<T> getAll(String orderBy, boolean isAsc); 1116 1117 /** 1118 * 根据ID移除对象. 1119 * 1120 * @see HibernateGenericDao#removeById(Class,Serializable) 1121 */ 1122 public void removeById(Serializable id); 1123 1124 /** 1125 * 取得Entity的Criteria. 1126 * 1127 * @see HibernateGenericDao#createCriteria(Class,Criterion[]) 1128 */ 1129 public Criteria createCriteria(Criterion... criterions); 1130 1131 /** 1132 * 取得Entity的Criteria,带排序参数. 1133 * 1134 * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[]) 1135 */ 1136 public Criteria createCriteria(String orderBy, boolean isAsc, 1137 Criterion... criterions); 1138 1139 /** 1140 * 根据属性名和属性值查询对象. 1141 * 1142 * @return 符合条件的对象列表 1143 * @see HibernateGenericDao#findBy(Class,String,Object) 1144 */ 1145 public List<T> findBy(String propertyName, Object value); 1146 1147 /** 1148 * 根据属性名和属性值查询对象,带排序参数. 1149 * 1150 * @return 符合条件的对象列表 1151 * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean) 1152 */ 1153 public List<T> findBy(String propertyName, Object value, String orderBy, 1154 boolean isAsc); 1155 1156 /** 1157 * 根据属性名和属性值查询单个对象. 1158 * 1159 * @return 符合条件的唯一对象 or null 1160 * @see HibernateGenericDao#findUniqueBy(Class,String,Object) 1161 */ 1162 public T findUniqueBy(String propertyName, Object value); 1163 1164 /** 1165 * 判断对象某些属性的值在数据库中唯一. 1166 * 1167 * @param uniquePropertyNames 1168 * 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" 1169 * @see HibernateGenericDao#isUnique(Class,Object,String) 1170 */ 1171 public boolean isUnique(Object entity, String uniquePropertyNames); 1172 1173 /** 1174 * 消除与 Hibernate Session 的关联 1175 * 1176 * @param entity 1177 */ 1178 public void evit(Object entity); 1179 1180 /*******************************************************************************************/ 1181 1182 /** 1183 * 取得所有状态为有效的对象. 1184 * 1185 * @see IUndeleteableEntityOperation#getAllValid() 1186 */ 1187 public List<T> getAllValid(); 1188 1189 /** 1190 * 获取过滤已删除对象的hql条件语句. 1191 * 1192 * @see IUndeleteableEntityOperation#getUnDeletableHQL() 1193 */ 1194 public String getUnDeletableHQL(); 1195 1196 /** 1197 * 获取过滤已删除对象的Criterion条件语句. 1198 * 1199 * @see UndeleteableEntityOperation# 1200 */ 1201 public Criterion getUnDeletableCriterion(); 1202 1203 /** 1204 * 重载保存函数,在保存前先调用onValid(T),进行书名不重复等数据库相关的校验. 1205 * 1206 * @see #onValid(Object) 1207 * @see HibernateEntityDao#save(Object) 1208 */ 1209 public void saveOnValid(Object entity); 1210 1211 /** 1212 * 删除对象，如果是Undeleteable的entity,设置对象的状态而不是直接删除. 1213 * 1214 * @see HibernateEntityDao#remove(Object) 1215 */ 1216 public void removeUndeleteable(Object entity); 1217 1218 /** 1219 * 与数据库相关的校验,比如判断名字在数据库里有没有重复, 在保存时被调用,在子类重载. 1220 * 1221 * @see #save(Object) 1222 */ 1223 public void onValid(T entity); 1224 1225 /** 1226 * 根据Map中的条件的Criteria查询. 1227 * 1228 * @param map Map中仅包含条件名与条件值，默认全部相同,可重载。 1229 */ 1230 @SuppressWarnings("unchecked") 1231 public List<T> find(Map map); 1232 1233 /** 1234 * 根据Map中的条件的Criteria查询. 1235 * 1236 * @param map Map中仅包含条件名与条件值,默认全部相同,可重载. 1237 */ 1238 @SuppressWarnings("unchecked") 1239 public List<T> find(Criteria criteria, Map map); 1240 1241 /*******************************************************************************************/ 1242 1243 /** 1244 * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常. 1245 */ 1246 public T get(Class<T> entityClass, Serializable id); 1247 1248 /** 1249 * 获取全部对象. 1250 */ 1251 public List<T> getAll(Class<T> entityClass); 1252 1253 /** 1254 * 获取全部对象,带排序字段与升降序参数. 1255 */ 1256 public List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc); 1257 1258 /** 1259 * 保存对象. 1260 */ 1261 public void save(Object o); 1262 1263 /** 1264 * 删除对象. 1265 */ 1266 public void remove(Object o); 1267 1268 public void flush(); 1269 1270 public void clear(); 1271 1272 /** 1273 * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置. 1274 * 留意可以连续设置,如下： 1275 * <pre> 1276 * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list(); 1277 * </pre> 1278 * 调用方式如下： 1279 * <pre> 1280 * dao.createQuery(hql) 1281 * dao.createQuery(hql,arg0); 1282 * dao.createQuery(hql,arg0,arg1); 1283 * dao.createQuery(hql,new Object[arg0,arg1,arg2]) 1284 * </pre> 1285 * 1286 * @param values 可变参数. 1287 */ 1288 public Query createQuery(String hql, Object... values); 1289 1290 /** 1291 * 创建Criteria对象. 1292 * 1293 * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)} 1294 */ 1295 public Criteria createCriteria(Class<T> entityClass, Criterion... criterions); 1296 1297 /** 1298 * 创建Criteria对象，带排序字段与升降序字段. 1299 * 1300 * @see #createCriteria(Class,Criterion[]) 1301 */ 1302 public Criteria createCriteria(Class<T> entityClass, String orderBy, boolean isAsc, Criterion... criterions); 1303 1304 /** 1305 * 根据hql查询,直接使用HibernateTemplate的find函数. 1306 * 1307 * @param values 可变参数,见{@link #createQuery(String,Object...)} 1308 */ 1309 @SuppressWarnings("unchecked") 1310 public List find(String hql, Object... values); 1311 1312 /** 1313 * 根据属性名和属性值查询对象. 1314 * 1315 * @return 符合条件的对象列表 1316 */ 1317 public List<T> findBy(Class<T> entityClass, String propertyName, Object value); 1318 1319 /** 1320 * 根据属性名和属性值查询对象,带排序参数. 1321 */ 1322 public List<T> findBy(Class<T> entityClass, String propertyName, Object value, String orderBy, boolean isAsc); 1323 1324 /** 1325 * 根据属性名和属性值查询唯一对象. 1326 * 1327 * @return 符合条件的唯一对象 or null if not found. 1328 */ 1329 public T findUniqueBy(Class<T> entityClass, String propertyName, Object value); 1330 1331 /** 1332 * 分页查询函数，使用hql. 1333 * 1334 * @param pageNo 页号,从1开始. 1335 */ 1336 public Page pagedQuery(String hql, int pageNo, int pageSize, Object... values); 1337 1338 /** 1339 * @author Scott.wanglei 1340 * @since 2008-7-21 1341 * @param hql 查询sql 1342 * @param start 分页从哪一条数据开始 1343 * @param pageSize 每一个页面的大小 1344 * @param values 查询条件 1345 * @return page对象 1346 */ 1347 public Page dataQuery(String hql, int start, int pageSize, Object... values); 1348 1349 /** 1350 * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>. 1351 * 1352 * @param pageNo 页号,从1开始. 1353 * @return 含总记录数和当前页数据的Page对象. 1354 */ 1355 public Page pagedQuery(Criteria criteria, int pageNo, int pageSize); 1356 1357 /** 1358 * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>. 1359 * 1360 * @param pageNo 页号,从1开始. 1361 * @return 含总记录数和当前页数据的Page对象. 1362 */ 1363 @SuppressWarnings("unchecked") 1364 public Page pagedQuery(Class entityClass, int pageNo, int pageSize, Criterion... criterions); 1365 1366 /** 1367 * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>. 1368 * 1369 * @param pageNo 页号,从1开始. 1370 * @return 含总记录数和当前页数据的Page对象. 1371 */ 1372 @SuppressWarnings("unchecked") 1373 public Page pagedQuery(Class entityClass, int pageNo, int pageSize, String orderBy, boolean isAsc, 1374 Criterion... criterions); 1375 1376 /** 1377 * 判断对象某些属性的值在数据库中是否唯一. 1378 * 1379 * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" 1380 */ 1381 public boolean isUnique(Class<T> entityClass, Object entity, String uniquePropertyNames); 1382 1383 /** 1384 * 取得对象的主键值,辅助函数. 1385 */ 1386 @SuppressWarnings("unchecked") 1387 public Serializable getId(Class entityClass, Object entity) throws NoSuchMethodException, IllegalAccessException, 1388 InvocationTargetException ; 1389 1390 /** 1391 * 取得对象的主键名,辅助函数. 1392 */ 1393 @SuppressWarnings("unchecked") 1394 public String getIdName(Class clazz); 1395 } 1396 1397 BaseDao.java 1398 /** 1399 * 1400 */ 1401 package com.demonstration.hibernate.basedao; 1402 import java.io.Serializable; 1403 import java.lang.reflect.InvocationTargetException; 1404 import java.util.List; 1405 import java.util.Map; 1406 import org.hibernate.Criteria; 1407 import org.hibernate.Query; 1408 import org.hibernate.criterion.Criterion; 1409 import com.demonstration.hibernate.dao.HibernateEntityDao; 1410 import com.demonstration.hibernate.dao.HibernateGenericDao; 1411 import com.demonstration.hibernate.dao.extend.HibernateEntityExtendDao; 1412 import com.demonstration.hibernate.dao.extend.IUndeleteableEntityOperation; 1413 import com.demonstration.hibernate.dao.support.Page; 1414 1415 /** 1416 * @author 1417 * 1418 * IBaseDao的实现类通过spring注入HibernateEntityDao和HibernateEntityExtendDao来实现 1419 */ 1420 public class BaseDao<T> implements IBaseDao<T> { 1421 protected Class<T> entityClass;// DAO所管理的Entity类型. 1422 private HibernateEntityDao<T> hedao; 1423 private HibernateEntityExtendDao<T> hexdao; 1424 1425 1426 public void setHedao(HibernateEntityDao<T> hedao) { 1427 hedao.setEntityClass(entityClass); 1428 this.hedao=hedao; 1429 } 1430 public void setHexdao(HibernateEntityExtendDao<T> hexdao) { 1431 hexdao.setEntityClass(entityClass); 1432 this.hexdao=hexdao; 1433 } 1434 1435 /** 1436 *让spring提供构造函数注入 1437 */ 1438 public BaseDao(Class<T> type) { 1439 this.entityClass = type; 1440 } 1441 1442 public BaseDao(){} 1443 /** 1444 * 根据ID获取对象. 1445 * 1446 * @see HibernateGenericDao#getId(Class,Object) 1447 */ 1448 public T get(Serializable id) { 1449 return hedao.get(id); 1450 } 1451 /** 1452 * 获取全部对象 1453 * 1454 * @see HibernateGenericDao#getAll(Class) 1455 */ 1456 public List<T> getAll() { 1457 return hedao.getAll(); 1458 } 1459 1460 /** 1461 * 获取全部对象,带排序参数. 1462 * 1463 * @see HibernateGenericDao#getAll(Class,String,boolean) 1464 */ 1465 public List<T> getAll(String orderBy, boolean isAsc) { 1466 return hedao.getAll(orderBy, isAsc); 1467 } 1468 /** 1469 * 根据ID移除对象. 1470 * 1471 * @see HibernateGenericDao#removeById(Class,Serializable) 1472 */ 1473 public void removeById(Serializable id) { 1474 hedao.removeById(id); 1475 } 1476 /** 1477 * 取得Entity的Criteria. 1478 * 1479 * @see HibernateGenericDao#createCriteria(Class,Criterion[]) 1480 */ 1481 public Criteria createCriteria(Criterion... criterions) { 1482 return hedao.createCriteria(criterions); 1483 } 1484 /** 1485 * 取得Entity的Criteria,带排序参数. 1486 * 1487 * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[]) 1488 */ 1489 public Criteria createCriteria(String orderBy, boolean isAsc, 1490 Criterion... criterions) { 1491 return hedao.createCriteria(orderBy, isAsc, criterions); 1492 } 1493 /** 1494 * 根据属性名和属性值查询对象. 1495 * 1496 * @return 符合条件的对象列表 1497 * @see HibernateGenericDao#findBy(Class,String,Object) 1498 */ 1499 public List<T> findBy(String propertyName, Object value) { 1500 return hedao.findBy(propertyName, value); 1501 } 1502 /** 1503 * 根据属性名和属性值查询对象,带排序参数. 1504 * 1505 * @return 符合条件的对象列表 1506 * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean) 1507 */ 1508 public List<T> findBy(String propertyName, Object value, String orderBy, 1509 boolean isAsc) { 1510 return hedao.findBy(propertyName, value, orderBy, isAsc); 1511 } 1512 /** 1513 * 根据属性名和属性值查询单个对象. 1514 * 1515 * @return 符合条件的唯一对象 or null 1516 * @see HibernateGenericDao#findUniqueBy(Class,String,Object) 1517 */ 1518 public T findUniqueBy(String propertyName, Object value) { 1519 return hedao.findUniqueBy(propertyName, value); 1520 } 1521 /** 1522 * 判断对象某些属性的值在数据库中唯一. 1523 * 1524 * @param uniquePropertyNames 1525 * 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" 1526 * @see HibernateGenericDao#isUnique(Class,Object,String) 1527 */ 1528 public boolean isUnique(Object entity, String uniquePropertyNames) { 1529 return hedao.isUnique(entity, uniquePropertyNames); 1530 } 1531 /** 1532 * 消除与 Hibernate Session 的关联 1533 * 1534 * @param entity 1535 */ 1536 public void evit(Object entity) { 1537 hedao.evit(entity); 1538 } 1539 /** 1540 * 取得所有状态为有效的对象. 1541 * 1542 * @see IUndeleteableEntityOperation#getAllValid() 1543 */ 1544 public List<T> getAllValid() { 1545 return hexdao.getAllValid(); 1546 } 1547 /** 1548 * 获取过滤已删除对象的hql条件语句. 1549 * 1550 * @see IUndeleteableEntityOperation#getUnDeletableHQL() 1551 */ 1552 public String getUnDeletableHQL() { 1553 return hexdao.getUnDeletableHQL(); 1554 } 1555 /** 1556 * 获取过滤已删除对象的Criterion条件语句. 1557 * 1558 * @see UndeleteableEntityOperation# 1559 */ 1560 public Criterion getUnDeletableCriterion() { 1561 return hexdao.getUnDeletableCriterion(); 1562 } 1563 /** 1564 * 重载保存函数,在保存前先调用onValid(T),进行书名不重复等数据库相关的校验. 1565 * 1566 * @see #onValid(Object) 1567 * @see HibernateEntityDao#save(Object) 1568 */ 1569 public void saveOnValid(Object entity) { 1570 hexdao.save(entity); 1571 } 1572 /** 1573 * 删除对象，如果是Undeleteable的entity,设置对象的状态而不是直接删除. 1574 * 1575 * @see HibernateEntityDao#remove(Object) 1576 */ 1577 public void removeUndeleteable(Object entity) { 1578 hexdao.remove(entity); 1579 } 1580 /** 1581 * 与数据库相关的校验,比如判断名字在数据库里有没有重复, 在保存时被调用,在此可重写. 1582 * 1583 * @see #save(Object) 1584 */ 1585 public void onValid(T entity) { 1586 1587 } 1588 /** 1589 * 根据Map中的条件的Criteria查询. 1590 * 1591 * @param map Map中仅包含条件名与条件值，默认全部相同,可重载。 1592 */ 1593 @SuppressWarnings("unchecked") 1594 public List<T> find(Map map) { 1595 return hexdao.find(map); 1596 } 1597 /** 1598 * 根据Map中的条件的Criteria查询. 1599 * 1600 * @param map Map中仅包含条件名与条件值,默认全部相同,可重载. 1601 */ 1602 @SuppressWarnings("unchecked") 1603 public List<T> find(Criteria criteria, Map map) { 1604 return hexdao.find(criteria, map); 1605 } 1606 /** 1607 * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常. 1608 */ 1609 public T get(Class<T> entityClass, Serializable id) { 1610 return hedao.get(entityClass, id); 1611 } 1612 /** 1613 * 获取全部对象. 1614 */ 1615 public List<T> getAll(Class<T> entityClass) { 1616 return hedao.getAll(entityClass); 1617 } 1618 /** 1619 * 获取全部对象,带排序字段与升降序参数. 1620 */ 1621 public List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc) { 1622 return hedao.getAll(entityClass, orderBy, isAsc); 1623 } 1624 /** 1625 * 保存对象. 1626 */ 1627 public void save(Object o) { 1628 hedao.save(o); 1629 } 1630 /** 1631 * 删除对象. 1632 */ 1633 public void remove(Object o) { 1634 hedao.remove(o); 1635 } 1636 1637 public void flush(){ 1638 hedao.flush(); 1639 } 1640 1641 public void clear(){ 1642 hedao.clear(); 1643 } 1644 /** 1645 * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置. 1646 * 留意可以连续设置,如下： 1647 * <pre> 1648 * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list(); 1649 * </pre> 1650 * 调用方式如下： 1651 * <pre> 1652 * dao.createQuery(hql) 1653 * dao.createQuery(hql,arg0); 1654 * dao.createQuery(hql,arg0,arg1); 1655 * dao.createQuery(hql,new Object[arg0,arg1,arg2]) 1656 * </pre> 1657 * 1658 * @param values 可变参数. 1659 */ 1660 public Query createQuery(String hql, Object... values) { 1661 1662 return hedao.createQuery(hql, values); 1663 } 1664 /** 1665 * 创建Criteria对象. 1666 * 1667 * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)} 1668 */ 1669 public Criteria createCriteria(Class<T> entityClass, 1670 Criterion... criterions) { 1671 1672 return hedao.createCriteria(entityClass, criterions); 1673 } 1674 /** 1675 * 创建Criteria对象，带排序字段与升降序字段. 1676 * 1677 * @see #createCriteria(Class,Criterion[]) 1678 */ 1679 public Criteria createCriteria(Class<T> entityClass, String orderBy, 1680 boolean isAsc, Criterion... criterions) { 1681 return hedao.createCriteria(entityClass, orderBy, isAsc, criterions); 1682 } 1683 /** 1684 * 根据hql查询,直接使用HibernateTemplate的find函数. 1685 * 1686 * @param values 可变参数,见{@link #createQuery(String,Object...)} 1687 */ 1688 @SuppressWarnings("unchecked") 1689 public List find(String hql, Object... values) { 1690 return hedao.find(hql, values); 1691 } 1692 /** 1693 * 根据属性名和属性值查询对象. 1694 * 1695 * @return 符合条件的对象列表 1696 */ 1697 public List<T> findBy(Class<T> entityClass, String propertyName, 1698 Object value) { 1699 1700 return hedao.findBy(entityClass, propertyName, value); 1701 } 1702 /** 1703 * 根据属性名和属性值查询对象,带排序参数. 1704 */ 1705 public List<T> findBy(Class<T> entityClass, String propertyName, 1706 Object value, String orderBy, boolean isAsc) { 1707 return hedao.findBy(entityClass, propertyName, value, orderBy, isAsc); 1708 } 1709 /** 1710 * 根据属性名和属性值查询唯一对象. 1711 * 1712 * @return 符合条件的唯一对象 or null if not found. 1713 */ 1714 public T findUniqueBy(Class<T> entityClass, String propertyName, 1715 Object value) { 1716 return hedao.findUniqueBy(propertyName, value); 1717 } 1718 /** 1719 * 分页查询函数，使用hql. 1720 * 1721 * @param pageNo 页号,从1开始. 1722 */ 1723 public Page pagedQuery(String hql, int pageNo, int pageSize, 1724 Object... values) { 1725 return hedao.pagedQuery(hql, pageNo, pageSize, values); 1726 } 1727 /** 1728 * @author Scott.wanglei 1729 * @since 2008-7-21 1730 * @param hql 查询sql 1731 * @param start 分页从哪一条数据开始 1732 * @param pageSize 每一个页面的大小 1733 * @param values 查询条件 1734 * @return page对象 1735 */ 1736 public Page dataQuery(String hql, int start, int pageSize, Object... values) { 1737 return hedao.dataQuery(hql, start, pageSize, values); 1738 } 1739 /** 1740 * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>. 1741 * 1742 * @param pageNo 页号,从1开始. 1743 * @return 含总记录数和当前页数据的Page对象. 1744 */ 1745 public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) { 1746 return hedao.pagedQuery(criteria, pageNo, pageSize); 1747 } 1748 1749 /** 1750 * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>. 1751 * 1752 * @param pageNo 页号,从1开始. 1753 * @return 含总记录数和当前页数据的Page对象. 1754 */ 1755 @SuppressWarnings("unchecked") 1756 public Page pagedQuery(Class entityClass, int pageNo, int pageSize, 1757 Criterion... criterions) { 1758 return hedao.pagedQuery(entityClass, pageNo, pageSize, criterions); 1759 } 1760 @SuppressWarnings("unchecked") 1761 public Page pagedQuery(Class entityClass, int pageNo, int pageSize, 1762 String orderBy, boolean isAsc, Criterion... criterions) { 1763 return hedao.pagedQuery(entityClass, pageNo, pageSize, orderBy, isAsc, criterions); 1764 } 1765 /** 1766 * 判断对象某些属性的值在数据库中是否唯一. 1767 * 1768 * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" 1769 */ 1770 public boolean isUnique(Class<T> entityClass, Object entity, 1771 String uniquePropertyNames) { 1772 return hedao.isUnique(entity, uniquePropertyNames); 1773 } 1774 /** 1775 * 取得对象的主键值,辅助函数. 1776 */ 1777 @SuppressWarnings("unchecked") 1778 public Serializable getId(Class entityClass, Object entity) 1779 throws NoSuchMethodException, IllegalAccessException, 1780 InvocationTargetException { 1781 return hedao.getId(entityClass, entity); 1782 } 1783 /** 1784 * 取得对象的主键名,辅助函数. 1785 */ 1786 @SuppressWarnings("unchecked") 1787 public String getIdName(Class clazz) { 1788 return hedao.getIdName(clazz); 1789 } 1790 } 1791 1792 使用时候的xml配置: 1793 <?xml version="1.0" encoding="UTF-8"?> 1794 <beans xmlns="http://www.springframework.org/schema/beans" 1795 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1796 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"> 1797 <bean id="hedao" 1798 class="com.demonstration.hibernate.dao.HibernateEntityDao" scope="prototype"> 1799 <property name="sessionFactory"> 1800 <ref bean="sessionFactory" /> 1801 </property> 1802 </bean> 1803 <bean id="hexdao" 1804 class="com.demonstration.hibernate.dao.extend.HibernateEntityExtendDao" scope="prototype"> 1805 <property name="sessionFactory"> 1806 <ref bean="sessionFactory" /> 1807 </property> 1808 </bean> 1809 1810 <!--使用泛型DAO作为抽象基类--> 1811 <bean id="baseDao" class="com.demonstration.hibernate.basedao.BaseDao" 1812 abstract="true" depends-on="hedao,hexdao"> 1813 <property name="hedao"> 1814 <ref bean="hedao" /> 1815 </property> 1816 <property name="hexdao"> 1817 <ref bean="hexdao" /> 1818 </property> 1819 </bean> 1820 1821 <!--下面这个dao没有写任何java代码完全有spring搞定 --> 1822 <!-- 配置实体类的DAO --> 1823 <bean id="demoDao" parent="baseDao"> 1824 <constructor-arg> 1825 <!--根据这个生成某一个实体的dao --> 1826 <value>com.demonstration.entityclass.Demodata</value> 1827 </constructor-arg> 1828 </bean> 1829 </beans>