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接口不变就不要修改业务层的代码了。
代码如下(从下到上)：

Page.Java

 

1. 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 {
14.     private static int DEFAULT_PAGE_SIZE = 20;
16.     private int pageSize = DEFAULT_PAGE_SIZE; // 每页的记录数
18.     private long start; // 当前页第一条数据在List中的位置,从0开始
20.     private Object data; // 当前页中存放的记录,类型一般为List
22.     private long totalCount; // 总记录数
24.     /**
25.      * 构造方法，只构造空页.
26.      */
27.     @SuppressWarnings("unchecked")
28.     public Page() {
29.         this(0, 0, DEFAULT_PAGE_SIZE, new ArrayList());
30.     }
32.     /**
33.      * 默认构造方法.
34.      *
35.      * @param start  本页数据在数据库中的起始位置
36.      * @param totalSize 数据库中总记录条数
37.      * @param pageSize  本页容量
38.      * @param data    本页包含的数据
39.      */
40.     public Page(long start, long totalSize, int pageSize, Object data) {
41.         this.pageSize = pageSize;
42.         this.start = start;
43.         this.totalCount = totalSize;
44.         this.data = data;
45.     }
47.     /**
48.      * 取总记录数.
49.      */
50.     public long getTotalCount() {
51.         return this.totalCount;
52.     }
54.     /**
55.      * 取总页数.
56.      */
57.     public long getTotalPageCount() {
58.         if (totalCount % pageSize == 0)
59.             return totalCount / pageSize;
60.         else
61.             return totalCount / pageSize + 1;
62.     }
64.     /**
65.      * 取每页数据容量.
66.      */
67.     public int getPageSize() {
68.         return pageSize;
69.     }
71.     /**
72.      * 取当前页中的记录.
73.      */
74.     public Object getResult() {
75.         return data;
76.     }
78.     /**
79.      * 取该页当前页码,页码从1开始.
80.      */
81.     public long getCurrentPageNo() {
82.         return start / pageSize + 1;
83.     }
85.     /**
86.      * 该页是否有下一页.
87.      */
88.     public boolean hasNextPage() {
89.         return this.getCurrentPageNo() < this.getTotalPageCount() - 1;
90.     }
92.     /**
93.      * 该页是否有上一页.
94.      */
95.     public boolean hasPreviousPage() {
96.         return this.getCurrentPageNo() > 1;
97.     }
99.     /**
100.      * 获取任一页第一条数据在数据集的位置，每页条数使用默认值.
101.      *
102.      * @see #getStartOfPage(int,int)
103.      */
104.     protected static int getStartOfPage(int pageNo) {
105.         return getStartOfPage(pageNo, DEFAULT_PAGE_SIZE);
106.     }
108.     /**
109.      * 获取任一页第一条数据在数据集的位置.
110.      *
111.      * @param pageNo   从1开始的页号
112.      * @param pageSize 每页记录条数
113.      * @return 该页第一条数据
114.      */
115.     public static int getStartOfPage(int pageNo, int pageSize) {
116.         return (pageNo - 1) * pageSize;
117.     }
118. }

GenericsUtils.java

 

 

1. package com.demonstration.hibernate.dao.support;
3. import java.lang.reflect.ParameterizedType;
4. import java.lang.reflect.Type;
6. import org.apache.commons.logging.Log;
7. import org.apache.commons.logging.LogFactory;
9. /**
10.  * Generics的util类.
11.  *
12.  * @author springside
13.  * 
14.  */
15. public class GenericsUtils {
16.     private static final Log log = LogFactory.getLog(GenericsUtils.class);
18.     private GenericsUtils() {
19.     }
21.     /**
22.      * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends GenricManager<Book>
23.      *
24.      * @param clazz The class to introspect
25.      * @return the first generic declaration, or <code>Object.class</code> if cannot be determined
26.      */
27.     @SuppressWarnings("unchecked")
28.     public static Class getSuperClassGenricType(Class clazz) {
29.         return getSuperClassGenricType(clazz, 0);
30.     }
32.     /**
33.      * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends GenricManager<Book>
34.      *
35.      * @param clazz clazz The class to introspect
36.      * @param index the Index of the generic ddeclaration,start from 0.
37.      * @return the index generic declaration, or <code>Object.class</code> if cannot be determined
38.      */
39.     @SuppressWarnings("unchecked")
40.     public static Class getSuperClassGenricType(Class clazz, int index) {
42.         Type genType = clazz.getGenericSuperclass();
44.         if (!(genType instanceof ParameterizedType)) {
45.             log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
46.             return Object.class;
47.         }
49.         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
51.         if (index >= params.length || index < 0) {
52.             log.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
53.                     + params.length);
54.             return Object.class;
55.         }
56.         if (!(params[index] instanceof Class)) {
57.             log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
58.             return Object.class;
59.         }
60.         return (Class) params[index];
61.     }
62. }

 

BeanUtils.java

 

1. package com.demonstration.hibernate.dao.support;
3. import java.lang.reflect.Field;
4. import java.lang.reflect.Method;
5. import java.util.ArrayList;
6. import java.util.List;
8. import org.apache.commons.lang.StringUtils;
9. import org.apache.commons.logging.Log;
10. import org.apache.commons.logging.LogFactory;
11. import org.springframework.util.Assert;
12. import org.springframework.util.ReflectionUtils;
14. /**
15.  * 扩展Apache Commons BeanUtils, 提供一些反射方面缺失功能的封装.
16.  * @author springside
17.  * 
18.  */
19. public class BeanUtils extends org.apache.commons.beanutils.BeanUtils {
21.     protected static final Log logger = LogFactory.getLog(BeanUtils.class);
23.     private BeanUtils() {
24.     }
26.     /**
27.      * 循环向上转型,获取对象的DeclaredField.
28.      *
29.      * @throws NoSuchFieldException 如果没有该Field时抛出.
30.      */
31.     public static Field getDeclaredField(Object object, String propertyName) throws NoSuchFieldException {
32.         Assert.notNull(object);
33.         Assert.hasText(propertyName);
34.         return getDeclaredField(object.getClass(), propertyName);
35.     }
37.     /**
38.      * 循环向上转型,获取对象的DeclaredField.
39.      *
40.      * @throws NoSuchFieldException 如果没有该Field时抛出.
41.      */
42.     @SuppressWarnings("unchecked")
43.     public static Field getDeclaredField(Class clazz, String propertyName) throws NoSuchFieldException {
44.         Assert.notNull(clazz);
45.         Assert.hasText(propertyName);
46.         for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {
47.             try {
48.                 return superClass.getDeclaredField(propertyName);
49.             } catch (NoSuchFieldException e) {
50.                 // Field不在当前类定义,继续向上转型
51.             }
52.         }
53.         throw new NoSuchFieldException("No such field: " + clazz.getName() + '.' + propertyName);
54.     }
56.     /**
57.      * 暴力获取对象变量值,忽略private,protected修饰符的限制.
58.      *
59.      * @throws NoSuchFieldException 如果没有该Field时抛出.
60.      */
61.     public static Object forceGetProperty(Object object, String propertyName) throws NoSuchFieldException {
62.         Assert.notNull(object);
63.         Assert.hasText(propertyName);
65.         Field field = getDeclaredField(object, propertyName);
67.         boolean accessible = field.isAccessible();
68.         field.setAccessible(true);
70.         Object result = null;
71.         try {
72.             result = field.get(object);
73.         } catch (IllegalAccessException e) {
74.             logger.info("error wont' happen");
75.         }
76.         field.setAccessible(accessible);
77.         return result;
78.     }
80.     /**
81.      * 暴力设置对象变量值,忽略private,protected修饰符的限制.
82.      *
83.      * @throws NoSuchFieldException 如果没有该Field时抛出.
84.      */
85.     public static void forceSetProperty(Object object, String propertyName, Object newValue)
86.             throws NoSuchFieldException {
87.         Assert.notNull(object);
88.         Assert.hasText(propertyName);
90.         Field field = getDeclaredField(object, propertyName);
91.         boolean accessible = field.isAccessible();
92.         field.setAccessible(true);
93.         try {
94.             field.set(object, newValue);
95.         } catch (IllegalAccessException e) {
96.             logger.info("Error won't happen");
97.         }
98.         field.setAccessible(accessible);
99.     }
101.     /**
102.      * 暴力调用对象函数,忽略private,protected修饰符的限制.
103.      *
104.      * @throws NoSuchMethodException 如果没有该Method时抛出.
105.      */
106.     @SuppressWarnings("unchecked")
107.     public static Object invokePrivateMethod(Object object, String methodName, Object... params)
108.             throws NoSuchMethodException {
109.         Assert.notNull(object);
110.         Assert.hasText(methodName);
111.         Class[] types = new Class[params.length];
112.         for (int i = 0; i < params.length; i++) {
113.             types[i] = params[i].getClass();
114.         }
116.         Class clazz = object.getClass();
117.         Method method = null;
118.         for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {
119.             try {
120.                 method = superClass.getDeclaredMethod(methodName, types);
121.                 break;
122.             } catch (NoSuchMethodException e) {
123.                 // 方法不在当前类定义,继续向上转型
124.             }
125.         }
127.         if (method == null)
128.             throw new NoSuchMethodException("No Such Method:" + clazz.getSimpleName() + methodName);
130.         boolean accessible = method.isAccessible();
131.         method.setAccessible(true);
132.         Object result = null;
133.         try {
134.             result = method.invoke(object, params);
135.         } catch (Exception e) {
136.             ReflectionUtils.handleReflectionException(e);
137.         }
138.         method.setAccessible(accessible);
139.         return result;
140.     }
142.     /**
143.      * 按Filed的类型取得Field列表.
144.      */
145.     @SuppressWarnings("unchecked")
146.     public static List<Field> getFieldsByType(Object object, Class type) {
147.         List<Field> list = new ArrayList<Field>();
148.         Field[] fields = object.getClass().getDeclaredFields();
149.         for (Field field : fields) {
150.             if (field.getType().isAssignableFrom(type)) {
151.                 list.add(field);
152.             }
153.         }
154.         return list;
155.     }
157.     /**
158.      * 按FiledName获得Field的类型.
159.      */
160.     @SuppressWarnings("unchecked")
161.     public static Class getPropertyType(Class type, String name) throws NoSuchFieldException {
162.         return getDeclaredField(type, name).getType();
163.     }
165.     /**
166.      * 获得field的getter函数名称.
167.      */
168.     @SuppressWarnings("unchecked")
169.     public static String getGetterName(Class type, String fieldName) {
170.         Assert.notNull(type, "Type required");
171.         Assert.hasText(fieldName, "FieldName required");
173.         if (type.getName().equals("boolean")) {
174.             return "is" + StringUtils.capitalize(fieldName);
175.         } else {
176.             return "get" + StringUtils.capitalize(fieldName);
177.         }
178.     }
180.     /**
181.      * 获得field的getter函数,如果找不到该方法,返回null.
182.      */
183.     @SuppressWarnings("unchecked")
184.     public static Method getGetterMethod(Class type, String fieldName) {
185.         try {
186.             return type.getMethod(getGetterName(type, fieldName));
187.         } catch (NoSuchMethodException e) {
188.             logger.error(e.getMessage(), e);
189.         }
190.         return null;
191.     }
192. }

 

IUndeleteableEntityOperation.java

 

1. package com.demonstration.hibernate.dao.extend;
3. import java.util.List;
5. import org.hibernate.criterion.Criterion;
7. /**
8.  * 定义如果支持Entity不被直接删除必须支持的Operation.
9.  *
10.  * @author springside
11.  * 
12.  */
13. public interface IUndeleteableEntityOperation<T> {
14.     /*
15.      * Undelete Entity用到的几个常量,因为要同时兼顾Interface与Annotation,所以集中放此.
16.      */
17.     String UNVALID_VALUE = "-1";
19.     String NORMAL_VALUE = "0";
21.     String STATUS = "status";
23.     /**
24.      * 取得所有状态为有效的对象.
25.      */
26.     List<T> getAllValid();
28.     /**
29.      * 删除对象，但如果是Undeleteable的entity,设置对象的状态而不是直接删除.
30.      */
31.     void remove(Object entity);
33.     /**
34.      * 获取过滤已删除对象的hql条件语句.
35.      */
36.     String getUnDeletableHQL();
37.     /**
38.      * 获取过滤已删除对象的Criterion条件语句.
39.      */
40.     Criterion getUnDeletableCriterion();
41. }

IUndeletableEntity.java

 

 

1. package com.demonstration.hibernate.dao.extend;
3. /**
4.  * 标识商业对象不能被删除,只能被设为无效的接口.
5.  *
6.  * @author springside
7.  * 
8.  */
9. public interface IUndeletableEntity {
10.     void setStatus(String status);
11. }

IUndeletable.java

 

 

1. package com.demonstration.hibernate.dao.extend;
3. import java.lang.annotation.ElementType;
4. import java.lang.annotation.Retention;
5. import java.lang.annotation.RetentionPolicy;
6. import java.lang.annotation.Target;
8. /**
9.  * 标识商业对象不能被删除,只能被设为无效的Annoation.
10.  * <p/>
11.  * 相比inferface的标示方式，annotation 方式更少侵入性,可以定义任意属性代表status,而默认为status属性.
12.  */
13. @Target({ElementType.TYPE})
14. @Retention(RetentionPolicy.RUNTIME)
15. public @interface IUndeletable {
16.     String status() default IUndeleteableEntityOperation.STATUS;
17. }

HibernateEntityExtendDao.java

 

 

1. package com.demonstration.hibernate.dao.extend;
3. import java.util.List;
4. import java.util.Map;
6. import org.apache.commons.beanutils.PropertyUtils;
7. import org.hibernate.Criteria;
8. import org.hibernate.criterion.Criterion;
9. import org.hibernate.criterion.Restrictions;
10. import org.springframework.util.Assert;
11. import org.springframework.util.ReflectionUtils;
13. import com.demonstration.hibernate.dao.HibernateEntityDao;
16. /**
17.  * 加强版的entity dao.
18.  * <p>自动处理Undeletable Entity.<br>
19.  * Undeletable Entity 在删除时只把状态设为无效,不会真正执行删除.<br>
20.  * Undeletable Entity 可以通过annotation或接口两种形式来声明.<br>
21.  * 其中annotation模式不限制状态列的属性名必须为"status",可以用注释来确定任意属性为状态属性.<br>
22.  * </p>
23.  *
24.  * @author springside
25.  *
26.  * @see HibernateEntityDao
27.  * @see EntityInfo
28.  * @see IUndeleteableEntityOperation
29.  * @see IUndeletable
30.  * @see IUndeletableEntity
31.  */
32. @SuppressWarnings("unchecked")
33. public class HibernateEntityExtendDao<T> extends HibernateEntityDao<T> implements IUndeleteableEntityOperation<T> {
34.     /**
35.      * 保存所管理的Entity的信息.
36.      */
37.     protected EntityInfo entityInfo;
39.     /**
40.      * 构造函数，初始化entity信息.
41.      */
42.     public HibernateEntityExtendDao() {
43.         entityInfo = new EntityInfo(entityClass);
44.     }
46.     /**
47.      * 取得所有状态为有效的对象.
48.      *
49.      * @see IUndeleteableEntityOperation#getAllValid()
50.      */
51.     public List<T> getAllValid() {
52.         Criteria criteria = createCriteria();
53.         if (entityInfo.isUndeletable)
54.             criteria.add(getUnDeletableCriterion());
55.         return criteria.list();
56.     }
58.     /**
59.      * 获取过滤已删除对象的hql条件语句.
60.      *
61.      * @see IUndeleteableEntityOperation#getUnDeletableHQL()
62.      */
63.     public String getUnDeletableHQL() {
64.         return entityInfo.statusProperty + "<>" + UNVALID_VALUE;
65.     }
67.     /**
68.      * 获取过滤已删除对象的Criterion条件语句.
69.      *
70.      * @see UndeleteableEntityOperation#
71.      */
72.     public Criterion getUnDeletableCriterion() {
73.         return Restrictions.not(Restrictions.eq(entityInfo.statusProperty, UNVALID_VALUE));
74.     }
76.     /**
77.      * 重载保存函数,在保存前先调用onValid(T),进行书名不重复等数据库相关的校验.
78.      *
79.      * @see #onValid(Object)
80.      * @see HibernateEntityDao#save(Object)
81.      */
82.     @Override
83.     public void save(Object entity) {
84.         Assert.isInstanceOf(getEntityClass(), entity);
85.         onValid((T) entity);
86.         super.save(entity);
87.     }
89.     /**
90.      * 删除对象，如果是Undeleteable的entity,设置对象的状态而不是直接删除.
91.      *
92.      * @see HibernateEntityDao#remove(Object)
93.      */
94.     @Override
95.     public void remove(Object entity) {
96.         if (entityInfo.isUndeletable) {
97.             try {
98.                 PropertyUtils.setProperty(entity, entityInfo.statusProperty, UNVALID_VALUE);
99.                 save(entity);
100.             } catch (Exception e) {
101.                 ReflectionUtils.handleReflectionException(e);
102.             }
103.         } else
104.             super.remove(entity);
105.     }
107.     /**
108.      * 与数据库相关的校验,比如判断名字在数据库里有没有重复, 在保存时被调用,在子类重载.
109.      *
110.      * @see #save(Object)
111.      */
112.     public void onValid(T entity) {
113.     }
115.     /**
116.      * 根据Map中的条件的Criteria查询.
117.      *
118.      * @param map Map中仅包含条件名与条件值，默认全部相同,可重载。
119.      */
120.     public List<T> find(Map map) {
121.         Criteria criteria = createCriteria();
122.         return find(criteria, map);
123.     }
125.     /**
126.      * 根据Map中的条件的Criteria查询.
127.      *
128.      * @param map Map中仅包含条件名与条件值,默认全部相同,可重载.
129.      */
130.     public List<T> find(Criteria criteria, Map map) {
131.         Assert.notNull(criteria);
132.         criteria.add(Restrictions.allEq(map));
133.         return criteria.list();
134.     }
135. }

 

 

EntityInfo.java

1. package com.demonstration.hibernate.dao.extend;
3. /**
4.  * 装载Entity信息的内部类.
5.  *
6.  * @author springside
7.  * 
8.  */
9. class EntityInfo {
10.     boolean isUndeletable = false; // entity是否undeleteable的标志
12.     String statusProperty; // 标识状态的属性名
14.     @SuppressWarnings("unchecked")
15.     public EntityInfo(Class entityClass) {
16.         init(entityClass);
17.     }
19.     /**
20.      * 初始函数,判断EntityClass是否UndeletableEntity.
21.      */
22.     @SuppressWarnings("unchecked")
23.     private void init(Class entityClass) {
24.         // 通过EntityClass的interface判断entity是否undeletable
25.         if (IUndeletableEntity.class.isAssignableFrom(entityClass)) {
26.             isUndeletable = true;
27.             statusProperty = IUndeleteableEntityOperation.STATUS;
28.         }
30.         // 通过EntityClass的annotation判断entity是否undeletable
31.         if (entityClass.isAnnotationPresent(IUndeletable.class)) {
32.             isUndeletable = true;
33.             IUndeletable anno = (IUndeletable) entityClass.getAnnotation(IUndeletable.class);
34.             statusProperty = anno.status();
35.         }
36.     }
37. }

IEntityDao.java

1. package com.demonstration.hibernate.dao;
3. import java.io.Serializable;
4. import java.util.List;
6. /**
7.  * 针对单个Entity对象的操作定义.不依赖于具体ORM实现方案.
8.  *
9.  * @author springside
10.  *
11.  */
12. public interface IEntityDao<T> {
14.     T get(Serializable id);
16.     List<T> getAll();
18.     void save(Object o);
20.     void remove(Object o);
22.     void removeById(Serializable id);
24.     /**
25.      * 获取Entity对象的主键名.
26.      */
27.     @SuppressWarnings("unchecked")
28.     String getIdName(Class clazz);
29. }

HibernateGenericDao.java

1. package com.demonstration.hibernate.dao;
3. import java.io.Serializable;
4. import java.lang.reflect.InvocationTargetException;
5. import java.util.ArrayList;
6. import java.util.List;
7. import java.util.regex.Matcher;
8. import java.util.regex.Pattern;
10. import org.apache.commons.beanutils.PropertyUtils;
11. import org.hibernate.Criteria;
12. import org.hibernate.Query;
13. import org.hibernate.criterion.CriteriaSpecification;
14. import org.hibernate.criterion.Criterion;
15. import org.hibernate.criterion.DetachedCriteria;
16. import org.hibernate.criterion.Order;
17. import org.hibernate.criterion.Projection;
18. import org.hibernate.criterion.Projections;
19. import org.hibernate.criterion.Restrictions;
20. import org.hibernate.impl.CriteriaImpl;
21. import org.hibernate.metadata.ClassMetadata;
22. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
23. import org.springframework.util.Assert;
24. import org.springframework.util.ReflectionUtils;
26. import com.demonstration.hibernate.dao.support.BeanUtils;
27. import com.demonstration.hibernate.dao.support.Page;
30. /**
31.  * Hibernate Dao的泛型基类.
32.  * <p/>
33.  * 继承于Spring的<code>HibernateDaoSupport</code>,提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换.
34.  *
35.  * @author springside
36.  * 
37.  * @see HibernateDaoSupport
38.  * @see HibernateEntityDao
39.  */
40. @SuppressWarnings("unchecked")
41. public class HibernateGenericDao extends HibernateDaoSupport {
42.     /**
43.      * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
44.      */
45.     public <T> T get(Class<T> entityClass, Serializable id) {
46.         return (T) getHibernateTemplate().load(entityClass, id);
47.     }
49.     /**
50.      * 获取全部对象.
51.      */
52.     public <T> List<T> getAll(Class<T> entityClass) {
53.         return getHibernateTemplate().loadAll(entityClass);
54.     }
56.     /**
57.      * 获取全部对象,带排序字段与升降序参数.
58.      */
59.     public <T> List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc) {
60.         Assert.hasText(orderBy);
61.         if (isAsc)
62.             return getHibernateTemplate().findByCriteria(
63.                     DetachedCriteria.forClass(entityClass).addOrder(Order.asc(orderBy)));
64.         else
65.             return getHibernateTemplate().findByCriteria(
66.                     DetachedCriteria.forClass(entityClass).addOrder(Order.desc(orderBy)));
67.     }
69.     /**
70.      * 保存对象.
71.      */
72.     public void save(Object o) {
73.         getHibernateTemplate().saveOrUpdate(o);
74.     }
76.     /**
77.      * 删除对象.
78.      */
79.     public void remove(Object o) {
80.         getHibernateTemplate().delete(o);
81.     }
83.     /**
84.      * 根据ID删除对象.
85.      */
86.     public <T> void removeById(Class<T> entityClass, Serializable id) {
87.         remove(get(entityClass, id));
88.     }
90.     public void flush() {
91.         getHibernateTemplate().flush();
92.     }
94.     public void clear() {
95.         getHibernateTemplate().clear();
96.     }
98.     /**
99.      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
100.      * 留意可以连续设置,如下：
101.      * <pre>
102.      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
103.      * </pre>
104.      * 调用方式如下：
105.      * <pre>
106.      *        dao.createQuery(hql)
107.      *        dao.createQuery(hql,arg0);
108.      *        dao.createQuery(hql,arg0,arg1);
109.      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
110.      * </pre>
111.      *
112.      * @param values 可变参数.
113.      */
114.     public Query createQuery(String hql, Object... values) {
115.         Assert.hasText(hql);
116.         Query query = getSession().createQuery(hql);
117.         for (int i = 0; i < values.length; i++) {
118.             query.setParameter(i, values[i]);
119.         }
120.         return query;
121.     }
123.     /**
124.      * 创建Criteria对象.
125.      *
126.      * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)}
127.      */
128.     public <T> Criteria createCriteria(Class<T> entityClass, Criterion... criterions) {
129.         Criteria criteria = getSession().createCriteria(entityClass);
130.         for (Criterion c : criterions) {
131.             criteria.add(c);
132.         }
133.         return criteria;
134.     }
136.     /**
137.      * 创建Criteria对象，带排序字段与升降序字段.
138.      *
139.      * @see #createCriteria(Class,Criterion[])
140.      */
141.     public <T> Criteria createCriteria(Class<T> entityClass, String orderBy, boolean isAsc, Criterion... criterions) {
142.         Assert.hasText(orderBy);
144.         Criteria criteria = createCriteria(entityClass, criterions);
146.         if (isAsc)
147.             criteria.addOrder(Order.asc(orderBy));
148.         else
149.             criteria.addOrder(Order.desc(orderBy));
151.         return criteria;
152.     }
154.     /**
155.      * 根据hql查询,直接使用HibernateTemplate的find函数.
156.      *
157.      * @param values 可变参数,见{@link #createQuery(String,Object...)}
158.      */
159.     public List find(String hql, Object... values) {
160.         Assert.hasText(hql);
161.         return getHibernateTemplate().find(hql, values);
162.     }
164.     /**
165.      * 根据属性名和属性值查询对象.
166.      *
167.      * @return 符合条件的对象列表
168.      */
169.     public <T> List<T> findBy(Class<T> entityClass, String propertyName, Object value) {
170.         Assert.hasText(propertyName);
171.         return createCriteria(entityClass, Restrictions.eq(propertyName, value)).list();
172.     }
174.     /**
175.      * 根据属性名和属性值查询对象,带排序参数.
176.      */
177.     public <T> List<T> findBy(Class<T> entityClass, String propertyName, Object value, String orderBy, boolean isAsc) {
178.         Assert.hasText(propertyName);
179.         Assert.hasText(orderBy);
180.         return createCriteria(entityClass, orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
181.     }
183.     /**
184.      * 根据属性名和属性值查询唯一对象.
185.      *
186.      * @return 符合条件的唯一对象 or null if not found.
187.      */
188.     public <T> T findUniqueBy(Class<T> entityClass, String propertyName, Object value) {
189.         Assert.hasText(propertyName);
190.         return (T) createCriteria(entityClass, Restrictions.eq(propertyName, value)).uniqueResult();
191.     }
193.     /**
194.      * 分页查询函数，使用hql.
195.      *
196.      * @param pageNo 页号,从1开始.
197.      */
198.     public Page pagedQuery(String hql, int pageNo, int pageSize, Object... values) {
199.         Assert.hasText(hql);
200.         Assert.isTrue(pageNo >= 1, "pageNo should start from 1");
201.         // Count查询
202.         String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));
203.         List countlist = getHibernateTemplate().find(countQueryString, values);
204.         long totalCount = (Long) countlist.get(0);
206.         if (totalCount < 1)
207.             return new Page();
208.         // 实际查询返回分页对象
209.         int startIndex = Page.getStartOfPage(pageNo, pageSize);
210.         Query query = createQuery(hql, values);
211.         List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
213.         return new Page(startIndex, totalCount, pageSize, list);
214.     }
215.     
216.      /**
217.      * @author Scott.wanglei
218.      * @since  2008-7-21
219.      * @param hql 查询sql
220.      * @param start 分页从哪一条数据开始
221.      * @param pageSize 每一个页面的大小
222.      * @param values 查询条件
223.      * @return page对象
224.      */
225.     public Page dataQuery(String hql, int start, int pageSize, Object... values){
226.         // Count查询
227.         String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));
228.         List countlist = getHibernateTemplate().find(countQueryString, values);
229.         long totalCount = (Long) countlist.get(0);
231.         if (totalCount < 1)
232.             return new Page();
233.         // 实际查询返回分页对象
234.         int startIndex = start;
235.         Query query = createQuery(hql, values);
236.         List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
238.         return new Page(startIndex, totalCount, pageSize, list);
239.      }
240.     /**
241.      * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
242.      *
243.      * @param pageNo 页号,从1开始.
244.      * @return 含总记录数和当前页数据的Page对象.
245.      */
246.     public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {
247.         Assert.notNull(criteria);
248.         Assert.isTrue(pageNo >= 1, "pageNo should start from 1");
249.         CriteriaImpl impl = (CriteriaImpl) criteria;
251.         // 先把Projection和OrderBy条件取出来,清空两者来执行Count操作
252.         Projection projection = impl.getProjection();
253.         List<CriteriaImpl.OrderEntry> orderEntries;
254.         try {
255.             orderEntries = (List) BeanUtils.forceGetProperty(impl, "orderEntries");
256.             BeanUtils.forceSetProperty(impl, "orderEntries", new ArrayList());
257.         } catch (Exception e) {
258.             throw new InternalError(" Runtime Exception impossibility throw ");
259.         }
261.         // 执行查询
262.         int totalCount = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();
264.         // 将之前的Projection和OrderBy条件重新设回去
265.         criteria.setProjection(projection);
266.         if (projection == null) {
267.             criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
268.         }
270.         try {
271.             BeanUtils.forceSetProperty(impl, "orderEntries", orderEntries);
272.         } catch (Exception e) {
273.             throw new InternalError(" Runtime Exception impossibility throw ");
274.         }
276.         // 返回分页对象
277.         if (totalCount < 1)
278.             return new Page();
280.         int startIndex = Page.getStartOfPage(pageNo, pageSize);;
281.         List list = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();
282.         return new Page(startIndex, totalCount, pageSize, list);
283.     }
285.     /**
286.      * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.
287.      *
288.      * @param pageNo 页号,从1开始.
289.      * @return 含总记录数和当前页数据的Page对象.
290.      */
291.     public Page pagedQuery(Class entityClass, int pageNo, int pageSize, Criterion... criterions) {
292.         Criteria criteria = createCriteria(entityClass, criterions);
293.         return pagedQuery(criteria, pageNo, pageSize);
294.     }
296.     /**
297.      * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>.
298.      *
299.      * @param pageNo 页号,从1开始.
300.      * @return 含总记录数和当前页数据的Page对象.
301.      */
302.     public Page pagedQuery(Class entityClass, int pageNo, int pageSize, String orderBy, boolean isAsc,
303.                            Criterion... criterions) {
304.         Criteria criteria = createCriteria(entityClass, orderBy, isAsc, criterions);
305.         return pagedQuery(criteria, pageNo, pageSize);
306.     }
308.     /**
309.      * 判断对象某些属性的值在数据库中是否唯一.
310.      *
311.      * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
312.      */
313.     public <T> boolean isUnique(Class<T> entityClass, Object entity, String uniquePropertyNames) {
314.         Assert.hasText(uniquePropertyNames);
315.         Criteria criteria = createCriteria(entityClass).setProjection(Projections.rowCount());
316.         String[] nameList = uniquePropertyNames.split(",");
317.         try {
318.             // 循环加入唯一列
319.             for (String name : nameList) {
320.                 criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(entity, name)));
321.             }
323.             // 以下代码为了如果是update的情况,排除entity自身.
325.             String idName = getIdName(entityClass);
327.             // 取得entity的主键值
328.             Serializable id = getId(entityClass, entity);
330.             // 如果id!=null,说明对象已存在,该操作为update,加入排除自身的判断
331.             if (id != null)
332.                 criteria.add(Restrictions.not(Restrictions.eq(idName, id)));
333.         } catch (Exception e) {
334.             ReflectionUtils.handleReflectionException(e);
335.         }
336.         return (Integer) criteria.uniqueResult() == 0;
337.     }
339.     /**
340.      * 取得对象的主键值,辅助函数.
341.      */
342.     public Serializable getId(Class entityClass, Object entity) throws NoSuchMethodException, IllegalAccessException,
343.             InvocationTargetException {
344.         Assert.notNull(entity);
345.         Assert.notNull(entityClass);
346.         return (Serializable) PropertyUtils.getProperty(entity, getIdName(entityClass));
347.     }
349.     /**
350.      * 取得对象的主键名,辅助函数.
351.      */
352.     public String getIdName(Class clazz) {
353.         Assert.notNull(clazz);
354.         ClassMetadata meta = getSessionFactory().getClassMetadata(clazz);
355.         Assert.notNull(meta, "Class " + clazz + " not define in hibernate session factory.");
356.         String idName = meta.getIdentifierPropertyName();
357.         Assert.hasText(idName, clazz.getSimpleName() + " has no identifier property define.");
358.         return idName;
359.     }
361.     /**
362.      * 去除hql的select 子句，未考虑union的情况,用于pagedQuery.
363.      *
364.      * @see #pagedQuery(String,int,int,Object[])
365.      */
366.     private static String removeSelect(String hql) {
367.         Assert.hasText(hql);
368.         int beginPos = hql.toLowerCase().indexOf("from");
369.         Assert.isTrue(beginPos != -1, " hql : " + hql + " must has a keyword 'from'");
370.         return hql.substring(beginPos);
371.     }
373.     /**
374.      * 去除hql的orderby 子句，用于pagedQuery.
375.      *
376.      * @see #pagedQuery(String,int,int,Object[])
377.      */
378.     private static String removeOrders(String hql) {
379.         Assert.hasText(hql);
380.         Pattern p = Pattern.compile("order//s*by[//w|//W|//s|//S]*", Pattern.CASE_INSENSITIVE);
381.         Matcher m = p.matcher(hql);
382.         StringBuffer sb = new StringBuffer();
383.         while (m.find()) {
384.             m.appendReplacement(sb, "");
385.         }
386.         m.appendTail(sb);
387.         return sb.toString();
388.     }
389.     
390. }

HibernateEntityDao.java

1. package com.demonstration.hibernate.dao;
3. import java.io.Serializable;
4. import java.util.List;
5. import org.hibernate.Criteria;
6. import org.hibernate.criterion.Criterion;
8. import com.demonstration.hibernate.dao.support.GenericsUtils;
10. /**
11.  * 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类. <p/> 子类只要在类定义时指定所管理Entity的Class,
12.  * 即拥有对单个Entity对象的CRUD操作.
13.  * 
14.  * <pre>
15.  * public class UserManager extends HibernateEntityDao<User> {
16.  * }
17.  * </pre>
18.  * 
19.  * @author springside
20.  * 
21.  * @see HibernateGenericDao
22.  */
23. @SuppressWarnings("unchecked")
24. public class HibernateEntityDao<T> extends HibernateGenericDao implements
25.         IEntityDao<T> {
27.     protected Class<T> entityClass;// DAO所管理的Entity类型.
29.     /**
30.      * 在构造函数中将泛型T.class赋给entityClass.
31.      */
32.     public HibernateEntityDao() {
33.         entityClass = GenericsUtils.getSuperClassGenricType(getClass());
34.     }
36.     /**
37.      * 重载构造函数 让spring提供构造函数注入
38.      */
39.     public HibernateEntityDao(Class<T> type) {
40.         this.entityClass = type;
41.     }
42.     
43.     /**
44.      * 取得entityClass.JDK1.4不支持泛型的子类可以抛开Class<T> entityClass,重载此函数达到相同效果。
45.      */
46.     protected Class<T> getEntityClass() {
47.         return entityClass;
48.     }
49.     
50.     public void setEntityClass(Class<T> type){
51.         this.entityClass=type;
52.     }
54.     /**
55.      * 根据ID获取对象.
56.      * 
57.      * @see HibernateGenericDao#getId(Class,Object)
58.      */
59.     public T get(Serializable id) {
60.         return get(getEntityClass(), id);
61.     }
63.     /**
64.      * 获取全部对象
65.      * 
66.      * @see HibernateGenericDao#getAll(Class)
67.      */
68.     public List<T> getAll() {
69.         return getAll(getEntityClass());
70.     }
72.     /**
73.      * 获取全部对象,带排序参数.
74.      * 
75.      * @see HibernateGenericDao#getAll(Class,String,boolean)
76.      */
77.     public List<T> getAll(String orderBy, boolean isAsc) {
78.         return getAll(getEntityClass(), orderBy, isAsc);
79.     }
81.     /**
82.      * 根据ID移除对象.
83.      * 
84.      * @see HibernateGenericDao#removeById(Class,Serializable)
85.      */
86.     public void removeById(Serializable id) {
87.         removeById(getEntityClass(), id);
88.     }
90.     /**
91.      * 取得Entity的Criteria.
92.      * 
93.      * @see HibernateGenericDao#createCriteria(Class,Criterion[])
94.      */
95.     public Criteria createCriteria(Criterion... criterions) {
96.         return createCriteria(getEntityClass(), criterions);
97.     }
99.     /**
100.      * 取得Entity的Criteria,带排序参数.
101.      * 
102.      * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[])
103.      */
104.     public Criteria createCriteria(String orderBy, boolean isAsc,
105.             Criterion... criterions) {
106.         return createCriteria(getEntityClass(), orderBy, isAsc, criterions);
107.     }
109.     /**
110.      * 根据属性名和属性值查询对象.
111.      * 
112.      * @return 符合条件的对象列表
113.      * @see HibernateGenericDao#findBy(Class,String,Object)
114.      */
115.     public List<T> findBy(String propertyName, Object value) {
116.         return findBy(getEntityClass(), propertyName, value);
117.     }
119.     /**
120.      * 根据属性名和属性值查询对象,带排序参数.
121.      * 
122.      * @return 符合条件的对象列表
123.      * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean)
124.      */
125.     public List<T> findBy(String propertyName, Object value, String orderBy,
126.             boolean isAsc) {
127.         return findBy(getEntityClass(), propertyName, value, orderBy, isAsc);
128.     }
130.     /**
131.      * 根据属性名和属性值查询单个对象.
132.      * 
133.      * @return 符合条件的唯一对象 or null
134.      * @see HibernateGenericDao#findUniqueBy(Class,String,Object)
135.      */
136.     public T findUniqueBy(String propertyName, Object value) {
137.         return findUniqueBy(getEntityClass(), propertyName, value);
138.     }
140.     /**
141.      * 判断对象某些属性的值在数据库中唯一.
142.      * 
143.      * @param uniquePropertyNames
144.      *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
145.      * @see HibernateGenericDao#isUnique(Class,Object,String)
146.      */
147.     public boolean isUnique(Object entity, String uniquePropertyNames) {
148.         return isUnique(getEntityClass(), entity, uniquePropertyNames);
149.     }
151.     /**
152.      * 消除与 Hibernate Session 的关联
153.      * 
154.      * @param entity
155.      */
156.     public void evit(Object entity) {
157.         getHibernateTemplate().evict(entity);
158.     }
159. }

IBaseDao.java

1. /**
2.  * 
3.  */
4. package com.demonstration.hibernate.basedao;
6. import java.io.Serializable;
7. import java.lang.reflect.InvocationTargetException;
8. import java.util.List;
9. import java.util.Map;
11. import org.hibernate.Criteria;
12. import org.hibernate.Query;
13. import org.hibernate.criterion.Criterion;
15. import com.demonstration.hibernate.dao.HibernateEntityDao;
16. import com.demonstration.hibernate.dao.HibernateGenericDao;
17. import com.demonstration.hibernate.dao.extend.IUndeleteableEntityOperation;
18. import com.demonstration.hibernate.dao.support.Page;
21. /**
22.  * @author 
23.  * 
24.  * 提供hibernate dao的所有操作,
25.  * 实现类由spring注入HibernateEntityDao和HibernateEntityExtendDao来实现
26.  * 最大限度的解耦hibernate持久层的操作
27.  */
28. public interface IBaseDao<T> {
30.     /**
31.      * 根据ID获取对象.
32.      * 
33.      * @see HibernateGenericDao#getId(Class,Object)
34.      */
35.     public T get(Serializable id);
36.     
37.     /**
38.      * 获取全部对象
39.      * 
40.      * @see HibernateGenericDao#getAll(Class)
41.      */
42.     public List<T> getAll();
43.     
44.     /**
45.      * 获取全部对象,带排序参数.
46.      * 
47.      * @see HibernateGenericDao#getAll(Class,String,boolean)
48.      */
49.     public List<T> getAll(String orderBy, boolean isAsc);
50.     
51.     /**
52.      * 根据ID移除对象.
53.      * 
54.      * @see HibernateGenericDao#removeById(Class,Serializable)
55.      */
56.     public void removeById(Serializable id);
57.     
58.     /**
59.      * 取得Entity的Criteria.
60.      * 
61.      * @see HibernateGenericDao#createCriteria(Class,Criterion[])
62.      */
63.     public Criteria createCriteria(Criterion... criterions);
64.     
65.     /**
66.      * 取得Entity的Criteria,带排序参数.
67.      * 
68.      * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[])
69.      */
70.     public Criteria createCriteria(String orderBy, boolean isAsc,
71.             Criterion... criterions);
72.     
73.     /**
74.      * 根据属性名和属性值查询对象.
75.      * 
76.      * @return 符合条件的对象列表
77.      * @see HibernateGenericDao#findBy(Class,String,Object)
78.      */
79.     public List<T> findBy(String propertyName, Object value);
80.     
81.     /**
82.      * 根据属性名和属性值查询对象,带排序参数.
83.      * 
84.      * @return 符合条件的对象列表
85.      * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean)
86.      */
87.     public List<T> findBy(String propertyName, Object value, String orderBy,
88.             boolean isAsc);
89.     
90.     /**
91.      * 根据属性名和属性值查询单个对象.
92.      * 
93.      * @return 符合条件的唯一对象 or null
94.      * @see HibernateGenericDao#findUniqueBy(Class,String,Object)
95.      */
96.     public T findUniqueBy(String propertyName, Object value);
97.     
98.     /**
99.      * 判断对象某些属性的值在数据库中唯一.
100.      * 
101.      * @param uniquePropertyNames
102.      *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
103.      * @see HibernateGenericDao#isUnique(Class,Object,String)
104.      */
105.     public boolean isUnique(Object entity, String uniquePropertyNames);
106.     
107.     /**
108.      * 消除与 Hibernate Session 的关联
109.      * 
110.      * @param entity
111.      */
112.     public void evit(Object entity);
113.     
114.     /*******************************************************************************************/
115.     
116.     /**
117.      * 取得所有状态为有效的对象.
118.      *
119.      * @see IUndeleteableEntityOperation#getAllValid()
120.      */
121.     public List<T> getAllValid();
122.     
123.     /**
124.      * 获取过滤已删除对象的hql条件语句.
125.      *
126.      * @see IUndeleteableEntityOperation#getUnDeletableHQL()
127.      */
128.     public String getUnDeletableHQL();
129.     
130.     /**
131.      * 获取过滤已删除对象的Criterion条件语句.
132.      *
133.      * @see UndeleteableEntityOperation#
134.      */
135.     public Criterion getUnDeletableCriterion();
136.     
137.     /**
138.      * 重载保存函数,在保存前先调用onValid(T),进行书名不重复等数据库相关的校验.
139.      *
140.      * @see #onValid(Object)
141.      * @see HibernateEntityDao#save(Object)
142.      */
143.     public void saveOnValid(Object entity);
144.     
145.     /**
146.      * 删除对象，如果是Undeleteable的entity,设置对象的状态而不是直接删除.
147.      *
148.      * @see HibernateEntityDao#remove(Object)
149.      */
150.     public void removeUndeleteable(Object entity);
151.     
152.     /**
153.      * 与数据库相关的校验,比如判断名字在数据库里有没有重复, 在保存时被调用,在子类重载.
154.      *
155.      * @see #save(Object)
156.      */
157.     public void onValid(T entity);
158.     
159.     /**
160.      * 根据Map中的条件的Criteria查询.
161.      *
162.      * @param map Map中仅包含条件名与条件值，默认全部相同,可重载。
163.      */
164.     @SuppressWarnings("unchecked")
165.     public List<T> find(Map map);
166.     
167.     /**
168.      * 根据Map中的条件的Criteria查询.
169.      *
170.      * @param map Map中仅包含条件名与条件值,默认全部相同,可重载.
171.      */
172.     @SuppressWarnings("unchecked")
173.     public List<T> find(Criteria criteria, Map map);
174.     
175.     /*******************************************************************************************/
176.     
177.     /**
178.      * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
179.      */
180.     public T get(Class<T> entityClass, Serializable id);
181.     
182.     /**
183.      * 获取全部对象.
184.      */
185.     public  List<T> getAll(Class<T> entityClass);
186.     
187.     /**
188.      * 获取全部对象,带排序字段与升降序参数.
189.      */
190.     public  List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc);
191.     
192.     /**
193.      * 保存对象.
194.      */
195.     public void save(Object o);
196.     
197.     /**
198.      * 删除对象.
199.      */
200.     public void remove(Object o);
201.     
202.     public void flush();
203.     
204.     public void clear();
205.     
206.     /**
207.      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
208.      * 留意可以连续设置,如下：
209.      * <pre>
210.      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
211.      * </pre>
212.      * 调用方式如下：
213.      * <pre>
214.      *        dao.createQuery(hql)
215.      *        dao.createQuery(hql,arg0);
216.      *        dao.createQuery(hql,arg0,arg1);
217.      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
218.      * </pre>
219.      *
220.      * @param values 可变参数.
221.      */
222.     public Query createQuery(String hql, Object... values);
223.     
224.     /**
225.      * 创建Criteria对象.
226.      *
227.      * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)}
228.      */
229.     public  Criteria createCriteria(Class<T> entityClass, Criterion... criterions);
230.     
231.     /**
232.      * 创建Criteria对象，带排序字段与升降序字段.
233.      *
234.      * @see #createCriteria(Class,Criterion[])
235.      */
236.     public  Criteria createCriteria(Class<T> entityClass, String orderBy, boolean isAsc, Criterion... criterions);
237.     
238.     /**
239.      * 根据hql查询,直接使用HibernateTemplate的find函数.
240.      *
241.      * @param values 可变参数,见{@link #createQuery(String,Object...)}
242.      */
243.     @SuppressWarnings("unchecked")
244.     public List find(String hql, Object... values);
245.     
246.     /**
247.      * 根据属性名和属性值查询对象.
248.      *
249.      * @return 符合条件的对象列表
250.      */
251.     public  List<T> findBy(Class<T> entityClass, String propertyName, Object value);
252.     
253.     /**
254.      * 根据属性名和属性值查询对象,带排序参数.
255.      */
256.     public  List<T> findBy(Class<T> entityClass, String propertyName, Object value, String orderBy, boolean isAsc);
257.     
258.     /**
259.      * 根据属性名和属性值查询唯一对象.
260.      *
261.      * @return 符合条件的唯一对象 or null if not found.
262.      */
263.     public  T findUniqueBy(Class<T> entityClass, String propertyName, Object value);
264.     
265.     /**
266.      * 分页查询函数，使用hql.
267.      *
268.      * @param pageNo 页号,从1开始.
269.      */
270.     public Page pagedQuery(String hql, int pageNo, int pageSize, Object... values);
271.     
272.     /**
273.      * @author Scott.wanglei
274.      * @since  2008-7-21
275.      * @param hql 查询sql
276.      * @param start 分页从哪一条数据开始
277.      * @param pageSize 每一个页面的大小
278.      * @param values 查询条件
279.      * @return page对象
280.      */
281.     public Page dataQuery(String hql, int start, int pageSize, Object... values);
282.     
283.     /**
284.      * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
285.      *
286.      * @param pageNo 页号,从1开始.
287.      * @return 含总记录数和当前页数据的Page对象.
288.      */
289.     public Page pagedQuery(Criteria criteria, int pageNo, int pageSize);
290.     
291.     /**
292.      * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.
293.      *
294.      * @param pageNo 页号,从1开始.
295.      * @return 含总记录数和当前页数据的Page对象.
296.      */
297.     @SuppressWarnings("unchecked")
298.     public Page pagedQuery(Class entityClass, int pageNo, int pageSize, Criterion... criterions);
299.     
300.     /**
301.      * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>.
302.      *
303.      * @param pageNo 页号,从1开始.
304.      * @return 含总记录数和当前页数据的Page对象.
305.      */
306.     @SuppressWarnings("unchecked")
307.     public Page pagedQuery(Class entityClass, int pageNo, int pageSize, String orderBy, boolean isAsc,
308.                Criterion... criterions);
309.     
310.     /**
311.      * 判断对象某些属性的值在数据库中是否唯一.
312.      *
313.      * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
314.      */
315.     public  boolean isUnique(Class<T> entityClass, Object entity, String uniquePropertyNames);
316.     
317.     /**
318.      * 取得对象的主键值,辅助函数.
319.      */
320.     @SuppressWarnings("unchecked")
321.     public Serializable getId(Class entityClass, Object entity) throws NoSuchMethodException, IllegalAccessException,
322.     InvocationTargetException ;
323.     
324.     /**
325.      * 取得对象的主键名,辅助函数.
326.      */
327.     @SuppressWarnings("unchecked")
328.     public String getIdName(Class clazz);
329. }

BaseDao.java

1. /**
2.  * 
3.  */
4. package com.demonstration.hibernate.basedao;
6. import java.io.Serializable;
7. import java.lang.reflect.InvocationTargetException;
8. import java.util.List;
9. import java.util.Map;
11. import org.hibernate.Criteria;
12. import org.hibernate.Query;
13. import org.hibernate.criterion.Criterion;
15. import com.demonstration.hibernate.dao.HibernateEntityDao;
16. import com.demonstration.hibernate.dao.HibernateGenericDao;
17. import com.demonstration.hibernate.dao.extend.HibernateEntityExtendDao;
18. import com.demonstration.hibernate.dao.extend.IUndeleteableEntityOperation;
19. import com.demonstration.hibernate.dao.support.Page;
23. /**
24.  * @author 
25.  *
26.  * IBaseDao的实现类通过spring注入HibernateEntityDao和HibernateEntityExtendDao来实现
27.  */
28. public class BaseDao<T> implements IBaseDao<T> {
30.     protected Class<T> entityClass;// DAO所管理的Entity类型.
31.     private HibernateEntityDao<T> hedao;
32.     private HibernateEntityExtendDao<T> hexdao;
33.     
34.     
35.     public void setHedao(HibernateEntityDao<T> hedao) {
36.         hedao.setEntityClass(entityClass);
37.         this.hedao=hedao;
38.     }
40.     public void setHexdao(HibernateEntityExtendDao<T> hexdao) {
41.         hexdao.setEntityClass(entityClass);
42.         this.hexdao=hexdao;
43.     }
44.     
45.     /**
46.      *让spring提供构造函数注入
47.      */
48.     public BaseDao(Class<T> type) {
49.         this.entityClass = type;
50.     }
51.     
52.     public BaseDao(){}
53.     /**
54.      * 根据ID获取对象.
55.      * 
56.      * @see HibernateGenericDao#getId(Class,Object)
57.      */
58.     public T get(Serializable id) {
59.         return hedao.get(id);
60.     }
62.     /**
63.      * 获取全部对象
64.      * 
65.      * @see HibernateGenericDao#getAll(Class)
66.      */
67.     public List<T> getAll() {
68.         return hedao.getAll();
69.     }
72.     /**
73.      * 获取全部对象,带排序参数.
74.      * 
75.      * @see HibernateGenericDao#getAll(Class,String,boolean)
76.      */
77.     public List<T> getAll(String orderBy, boolean isAsc) {
78.         return hedao.getAll(orderBy, isAsc);
79.     }
81.     /**
82.      * 根据ID移除对象.
83.      * 
84.      * @see HibernateGenericDao#removeById(Class,Serializable)
85.      */
86.     public void removeById(Serializable id) {
87.         hedao.removeById(id);
88.     }
90.     /**
91.      * 取得Entity的Criteria.
92.      * 
93.      * @see HibernateGenericDao#createCriteria(Class,Criterion[])
94.      */
95.     public Criteria createCriteria(Criterion... criterions) {
96.         return hedao.createCriteria(criterions);
97.     }
99.     /**
100.      * 取得Entity的Criteria,带排序参数.
101.      * 
102.      * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[])
103.      */
104.     public Criteria createCriteria(String orderBy, boolean isAsc,
105.             Criterion... criterions) {
106.         return hedao.createCriteria(orderBy, isAsc, criterions);
107.     }
109.     /**
110.      * 根据属性名和属性值查询对象.
111.      * 
112.      * @return 符合条件的对象列表
113.      * @see HibernateGenericDao#findBy(Class,String,Object)
114.      */
115.     public List<T> findBy(String propertyName, Object value) {
116.         return hedao.findBy(propertyName, value);
117.     }
119.     /**
120.      * 根据属性名和属性值查询对象,带排序参数.
121.      * 
122.      * @return 符合条件的对象列表
123.      * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean)
124.      */
125.     public List<T> findBy(String propertyName, Object value, String orderBy,
126.             boolean isAsc) {
127.         return hedao.findBy(propertyName, value, orderBy, isAsc);
128.     }
130.     /**
131.      * 根据属性名和属性值查询单个对象.
132.      * 
133.      * @return 符合条件的唯一对象 or null
134.      * @see HibernateGenericDao#findUniqueBy(Class,String,Object)
135.      */
136.     public T findUniqueBy(String propertyName, Object value) {
137.         return hedao.findUniqueBy(propertyName, value);
138.     }
140.     /**
141.      * 判断对象某些属性的值在数据库中唯一.
142.      * 
143.      * @param uniquePropertyNames
144.      *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
145.      * @see HibernateGenericDao#isUnique(Class,Object,String)
146.      */
147.     public boolean isUnique(Object entity, String uniquePropertyNames) {
148.         return hedao.isUnique(entity, uniquePropertyNames);
149.     }
151.     /**
152.      * 消除与 Hibernate Session 的关联
153.      * 
154.      * @param entity
155.      */
156.     public void evit(Object entity) {
157.         hedao.evit(entity);
158.     }
160.     /**
161.      * 取得所有状态为有效的对象.
162.      *
163.      * @see IUndeleteableEntityOperation#getAllValid()
164.      */
165.     public List<T> getAllValid() {
166.         return hexdao.getAllValid();
167.     }
169.     /**
170.      * 获取过滤已删除对象的hql条件语句.
171.      *
172.      * @see IUndeleteableEntityOperation#getUnDeletableHQL()
173.      */
174.     public String getUnDeletableHQL() {
175.         return hexdao.getUnDeletableHQL();
176.     }
178.     /**
179.      * 获取过滤已删除对象的Criterion条件语句.
180.      *
181.      * @see UndeleteableEntityOperation#
182.      */
183.     public Criterion getUnDeletableCriterion() {
184.         return hexdao.getUnDeletableCriterion();
185.     }
187.     /**
188.      * 重载保存函数,在保存前先调用onValid(T),进行书名不重复等数据库相关的校验.
189.      *
190.      * @see #onValid(Object)
191.      * @see HibernateEntityDao#save(Object)
192.      */
193.     public void saveOnValid(Object entity) {
194.          hexdao.save(entity);
195.     }
197.     /**
198.      * 删除对象，如果是Undeleteable的entity,设置对象的状态而不是直接删除.
199.      *
200.      * @see HibernateEntityDao#remove(Object)
201.      */
202.     public void removeUndeleteable(Object entity) {
203.            hexdao.remove(entity);
204.     }
206.     /**
207.      * 与数据库相关的校验,比如判断名字在数据库里有没有重复, 在保存时被调用,在此可重写.
208.      *
209.      * @see #save(Object)
210.      */
211.     public void onValid(T entity) {
212.            
213.     }
215.     /**
216.      * 根据Map中的条件的Criteria查询.
217.      *
218.      * @param map Map中仅包含条件名与条件值，默认全部相同,可重载。
219.      */
220.     @SuppressWarnings("unchecked")
221.     public List<T> find(Map map) {
222.         return hexdao.find(map);
223.     }
225.     /**
226.      * 根据Map中的条件的Criteria查询.
227.      *
228.      * @param map Map中仅包含条件名与条件值,默认全部相同,可重载.
229.      */
230.     @SuppressWarnings("unchecked")
231.     public List<T> find(Criteria criteria, Map map) {
232.         return hexdao.find(criteria, map);
233.     }
235.     /**
236.      * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
237.      */
238.     public T get(Class<T> entityClass, Serializable id) {
239.         return hedao.get(entityClass, id);
240.     }
242.     /**
243.      * 获取全部对象.
244.      */
245.     public List<T> getAll(Class<T> entityClass) {
246.         return hedao.getAll(entityClass);
247.     }
249.     /**
250.      * 获取全部对象,带排序字段与升降序参数.
251.      */
252.     public List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc) {    
253.         return hedao.getAll(entityClass, orderBy, isAsc);
254.     }
256.     /**
257.      * 保存对象.
258.      */
259.     public void save(Object o) {
260.           hedao.save(o);
261.     }
263.     /**
264.      * 删除对象.
265.      */
266.     public void remove(Object o) {
267.          hedao.remove(o);
268.     }
269.     
270.     public void flush(){
271.         hedao.flush();
272.     }
273.     
274.     public void clear(){
275.         hedao.clear();
276.     }
278.     /**
279.      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
280.      * 留意可以连续设置,如下：
281.      * <pre>
282.      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
283.      * </pre>
284.      * 调用方式如下：
285.      * <pre>
286.      *        dao.createQuery(hql)
287.      *        dao.createQuery(hql,arg0);
288.      *        dao.createQuery(hql,arg0,arg1);
289.      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
290.      * </pre>
291.      *
292.      * @param values 可变参数.
293.      */
294.     public Query createQuery(String hql, Object... values) {
295.         
296.         return hedao.createQuery(hql, values);
297.     }
299.     /**
300.      * 创建Criteria对象.
301.      *
302.      * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)}
303.      */
304.     public Criteria createCriteria(Class<T> entityClass,
305.             Criterion... criterions) {
306.         
307.         return hedao.createCriteria(entityClass, criterions);
308.     }
310.     /**
311.      * 创建Criteria对象，带排序字段与升降序字段.
312.      *
313.      * @see #createCriteria(Class,Criterion[])
314.      */
315.     public Criteria createCriteria(Class<T> entityClass, String orderBy,
316.             boolean isAsc, Criterion... criterions) {
317.         return hedao.createCriteria(entityClass, orderBy, isAsc, criterions);
318.     }
320.     /**
321.      * 根据hql查询,直接使用HibernateTemplate的find函数.
322.      *
323.      * @param values 可变参数,见{@link #createQuery(String,Object...)}
324.      */
325.     @SuppressWarnings("unchecked")
326.     public List find(String hql, Object... values) {
327.         return hedao.find(hql, values);
328.     }
330.     /**
331.      * 根据属性名和属性值查询对象.
332.      *
333.      * @return 符合条件的对象列表
334.      */
335.     public  List<T> findBy(Class<T> entityClass, String propertyName,
336.             Object value) {
337.         
338.         return hedao.findBy(entityClass, propertyName, value);
339.     }
341.     /**
342.      * 根据属性名和属性值查询对象,带排序参数.
343.      */
344.     public List<T> findBy(Class<T> entityClass, String propertyName,
345.             Object value, String orderBy, boolean isAsc) {
346.         return hedao.findBy(entityClass, propertyName, value, orderBy, isAsc);
347.     }
349.     /**
350.      * 根据属性名和属性值查询唯一对象.
351.      *
352.      * @return 符合条件的唯一对象 or null if not found.
353.      */
354.     public T findUniqueBy(Class<T> entityClass, String propertyName,
355.             Object value) {
356.         return hedao.findUniqueBy(propertyName, value);
357.     }
359.     /**
360.      * 分页查询函数，使用hql.
361.      *
362.      * @param pageNo 页号,从1开始.
363.      */
364.     public Page pagedQuery(String hql, int pageNo, int pageSize,
365.             Object... values) {
366.         return hedao.pagedQuery(hql, pageNo, pageSize, values);
367.     }
369.     /**
370.      * @author Scott.wanglei
371.      * @since  2008-7-21
372.      * @param hql 查询sql
373.      * @param start 分页从哪一条数据开始
374.      * @param pageSize 每一个页面的大小
375.      * @param values 查询条件
376.      * @return page对象
377.      */
378.     public Page dataQuery(String hql, int start, int pageSize, Object... values) {
379.         return hedao.dataQuery(hql, start, pageSize, values);
380.     }
382.     /**
383.      * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
384.      *
385.      * @param pageNo 页号,从1开始.
386.      * @return 含总记录数和当前页数据的Page对象.
387.      */
388.     public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {
389.         return hedao.pagedQuery(criteria, pageNo, pageSize);
390.     }
391.     
392.     /**
393.      * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.
394.      *
395.      * @param pageNo 页号,从1开始.
396.      * @return 含总记录数和当前页数据的Page对象.
397.      */
398.     @SuppressWarnings("unchecked")
399.     public Page pagedQuery(Class entityClass, int pageNo, int pageSize,
400.             Criterion... criterions) {
401.         return hedao.pagedQuery(entityClass, pageNo, pageSize, criterions);
402.     }
404.     @SuppressWarnings("unchecked")
405.     public Page pagedQuery(Class entityClass, int pageNo, int pageSize,
406.             String orderBy, boolean isAsc, Criterion... criterions) {
407.         return hedao.pagedQuery(entityClass, pageNo, pageSize, orderBy, isAsc, criterions);
408.     }
410.     /**
411.      * 判断对象某些属性的值在数据库中是否唯一.
412.      *
413.      * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
414.      */
415.     public  boolean isUnique(Class<T> entityClass, Object entity,
416.             String uniquePropertyNames) {
417.         return hedao.isUnique(entity, uniquePropertyNames);
418.     }
420.     /**
421.      * 取得对象的主键值,辅助函数.
422.      */
423.     @SuppressWarnings("unchecked")
424.     public Serializable getId(Class entityClass, Object entity)
425.             throws NoSuchMethodException, IllegalAccessException,
426.             InvocationTargetException {
427.         return hedao.getId(entityClass, entity);
428.     }
430.     /**
431.      * 取得对象的主键名,辅助函数.
432.      */
433.     @SuppressWarnings("unchecked")
434.     public String getIdName(Class clazz) {
435.         return hedao.getIdName(clazz);
436.     }
438. }

使用时候的xml配置:

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
6.     <bean id="hedao"
7.         class="com.demonstration.hibernate.dao.HibernateEntityDao" scope="prototype">
8.         <property name="sessionFactory">
9.             <ref bean="sessionFactory" />
10.         </property>
11.     </bean>
13.     <bean id="hexdao"
14.         class="com.demonstration.hibernate.dao.extend.HibernateEntityExtendDao" scope="prototype">
15.         <property name="sessionFactory">
16.             <ref bean="sessionFactory" />
17.         </property>
18.     </bean>
21.     <!--使用泛型DAO作为抽象基类-->
22.     <bean id="baseDao" class="com.demonstration.hibernate.basedao.BaseDao"
23.         abstract="true" depends-on="hedao,hexdao">
24.         <property name="hedao">
25.             <ref bean="hedao" />
26.         </property>
27.         <property name="hexdao">
28.             <ref bean="hexdao" />
29.         </property>
30.     </bean>
31.     
32.     <!--下面这个dao没有写任何java代码完全有spring搞定 -->
33.     <!-- 配置实体类的DAO -->
34.     <bean id="demoDao" parent="baseDao">
35.         <constructor-arg>
36.                          <!--根据这个生成某一个实体的dao -->
37.             <value>com.demonstration.entityclass.Demodata</value>
38.         </constructor-arg>
39.     </bean>
41. </beans>