现在的位置: 首页 > 综合 > 正文

改进版的hibernate泛型dao(依赖spring)

2013年03月28日 ⁄ 综合 ⁄ 共 17446字 ⁄ 字号 小 中 大 ⁄ 评论关闭

 

引用地址：http://blog.csdn.net/tom_221x/archive/2008/12/26/3611535.aspx

另提供IBM 社区基于Hibernate编写的GenericDao参考文章地址

中文版：http://www.ibm.com/developerworks/cn/java/j-genericdao.html

英文版：http://www.ibm.com/developerworks/java/library/j-genericdao.html

结构看图：

HinernateEntityDao和HibernateGenericDao都继承在spring的HibernateDaoSupport
一个提供和实体相关的操作,一个提供和实体类无关的操作。
然后以组合的方式在BaseDao中使用,这样程序中全部使用IBaseDao接口来操作数据,便于修改和维护.
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">
  5.     <!-这个是和实体相关的dao,所以scope是prototype的每个实体对应一个对象->
  6.     <bean id="hedao"
  7.         class="com.hibernate.dao.extend.HibernateEntityDao" scope="prototype" lazy-init="true">
  8.         <property name="sessionFactory">
  9.             <ref bean="sessionFactory" />
  10.         </property>
  11.     </bean>
  12.     
  13.     <!-这个和具体实体无关,所有dao共享->
  14.     <bean id="hgdao"
  15.           class="com.hibernate.dao.generic.HibernateGenericDao">
  16.         <property name="sessionFactory">
  17.             <ref bean="sessionFactory" />
  18.         </property>
  19.     </bean>
  20.     <!--使用泛型DAO作为抽象基类-->
  21.     <bean id="baseDao" class="com.hibernate.dao.base.BaseDao"
  22.         abstract="true" depends-on="hedao,hgdao">
  23.         <property name="hedao">
  24.             <ref bean="hedao" />
  25.         </property>
  26.         <property name="hgdao">
  27.             <ref bean="hgdao" />
  28.         </property>
  29.     </bean>
  30.     
  31.     <!-- 配置实体Demodata的DAO -->
  32.     <bean id="demoDao" parent="baseDao">
  33.         <constructor-arg>
  34.             <value>com.hibernate.entityclass.Demodata</value>
  35.         </constructor-arg>
  36.     </bean>
  37.     
  38. </beans>

代码：

BaseDao.java
  1. package com.hibernate.dao.base;
  2. import java.io.Serializable;
  3. import java.util.List;
  4. import org.hibernate.Criteria;
  5. import org.hibernate.Query;
  6. import org.hibernate.criterion.Criterion;
  7. import org.springframework.orm.hibernate3.HibernateTemplate;
  8. import com.hibernate.dao.extend.HibernateEntityDao;
  9. import com.hibernate.dao.generic.HibernateGenericDao;
  10. import com.hibernate.dao.support.Page;
  11. /**
  12.  * 提供hibernate dao的所有操作,<br>
  13.  * 实现类由spring注入HibernateEntityDao和HibernateGenericDao来实现
  14.  * 
  15.  */
  16. public class BaseDao<T,PK extends Serializable> implements IBaseDao<T,PK> {
  17.     protected Class<T> entityClass;// DAO所管理的Entity类型.
  18.     private HibernateEntityDao<T,PK> hedao;
  19.     private HibernateGenericDao hgdao;
  20.     
  21.     public void setHedao(HibernateEntityDao<T, PK> hedao) {
  22.         hedao.setEntityClass(entityClass);
  23.         this.hedao = hedao;
  24.     }
  25.     public void setHgdao(HibernateGenericDao hgdao) {
  26.         this.hgdao = hgdao;
  27.     }
  28.     
  29.     /**
  30.      *让spring提供构造函数注入
  31.      */
  32.     public BaseDao(Class<T> type) {
  33.         this.entityClass = type;
  34.     }
  35.     
  36.     public BaseDao(){}
  37.     
  38.     /**
  39.      * 清除所有对象缓存
  40.      */
  41.     public void clear() {
  42.         
  43.         hgdao.clear();
  44.     }
  45.     /**
  46.      * 创建Criteria对象.
  47.      * @param criterions 可变的Restrictions条件列表
  48.      */
  49.     public Criteria createCriteria(Criterion... criterions) {
  50.         
  51.         return hedao.createCriteria(criterions);
  52.     }
  53.     /**
  54.      * 创建Criteria对象，带排序字段与升降序字段.
  55.      */
  56.     public Criteria createCriteria(String orderBy, boolean isAsc,
  57.             Criterion... criterions) {
  58.         
  59.         return hedao.createCriteria(orderBy, isAsc, criterions);
  60.     }
  61.     /**
  62.      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
  63.      * 留意可以连续设置,如下：
  64.      * <pre>
  65.      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
  66.      * </pre>
  67.      * 调用方式如下：
  68.      * <pre>
  69.      *        dao.createQuery(hql)
  70.      *        dao.createQuery(hql,arg0);
  71.      *        dao.createQuery(hql,arg0,arg1);
  72.      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
  73.      * </pre>
  74.      *
  75.      * @param values 可变参数.
  76.      */
  77.     public Query createQuery(String hql, Object... values) {
  78.         
  79.         return hgdao.createQuery(hql, values);
  80.     }
  81.     /**
  82.      * @param hql 查询sql
  83.      * @param start 分页从哪一条数据开始
  84.      * @param pageSize 每一个页面的大小
  85.      * @param values 查询条件
  86.      * @return page对象
  87.      */
  88.     public Page dataQuery(String hql, int start, int pageSize, Object... values) {
  89.         
  90.         return hgdao.dataQuery(hql, start, pageSize, values);
  91.     }
  92.     /**
  93.      * 消除与 Hibernate Session 的关联
  94.      * @param entity
  95.      */
  96.     public void evit(T entity) {
  97.         
  98.         hedao.evict(entity);
  99.     }
  100.     /**
  101.      * 执行本地sql语句获得标量数值列表
  102.      */
  103.     @SuppressWarnings("unchecked")
  104.     public List executeNativeSql(String sql) {
  105.         
  106.         return hgdao.executeNativeSql(sql);
  107.     }
  108.     /**
  109.      * 根据hql查询,直接使用HibernateTemplate的find函数.
  110.      * @param values 可变参数
  111.      */
  112.     @SuppressWarnings("unchecked")
  113.     public List find(String hql, Object... values) {
  114.         
  115.         return hgdao.find(hql, values);
  116.     }
  117.     /**
  118.      * 根据属性名和属性值查询对象.
  119.      * @return 符合条件的对象列表
  120.      */
  121.     public List<T> findBy(String propertyName, Object value) {
  122.         
  123.         return hedao.findBy(propertyName, value);
  124.     }
  125.     /**
  126.      * 根据属性名和属性值查询对象,带排序参数.
  127.      */
  128.     public List<T> findBy(String propertyName, Object value, String orderBy,
  129.             boolean isAsc) {
  130.         
  131.         return hedao.findBy(propertyName, value, orderBy, isAsc);
  132.     }
  133.     /**
  134.      * 根据属性名和属性值查询唯一对象.
  135.      * @return 符合条件的唯一对象 or null if not found.
  136.      */
  137.     public T findUniqueBy(String propertyName, Object value) {
  138.         
  139.         return hedao.findUniqueBy(propertyName, value);
  140.     }
  141.     /**
  142.      * 执行一些必须的sql语句把内存中的对象同步到jdbc的链接中
  143.      */
  144.     public void flush() {
  145.         
  146.         hgdao.flush();
  147.     }
  148.     
  149.     /**
  150.      * 根据Serializable类型的id获取实体对象<p/>
  151.      * 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
  152.      * @param id
  153.      */
  154.     public T get(PK id) {
  155.         
  156.         return hedao.get(id);
  157.     }
  158.     /**
  159.      * 获取实体类型的全部对象
  160.      */
  161.     public List<T> getAll() {
  162.         
  163.         return hedao.getAll();
  164.     }
  165.     /**
  166.      * 获取全部对象,带排序字段与升降序参数.
  167.      */
  168.     public List<T> getAll(String orderBy, boolean isAsc) {
  169.         
  170.         return hedao.getAll(orderBy, isAsc);
  171.     }
  172.     /**
  173.      * 直接使用spring提供的HibernateTemplate
  174.      */
  175.     public HibernateTemplate getHibernateTemplate() {
  176.         
  177.         return hgdao.getHibernateTemplate();
  178.     }
  179.     /**
  180.      * 判断对象某些属性的值在数据库中是否唯一.
  181.      *
  182.      * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
  183.      */
  184.     public boolean isUnique(T entity, String uniquePropertyNames) {
  185.         
  186.         return hedao.isUnique(entity, uniquePropertyNames);
  187.     }
  188.     /**
  189.      * 分页查询函数，使用hql.
  190.      *
  191.      * @param pageNo 页号,从1开始.
  192.      */
  193.     public Page pagedQuery(String hql, int pageNo, int pageSize,
  194.             Object... values) {
  195.         
  196.         return hgdao.pagedQuery(hql, pageNo, pageSize, values);
  197.     }
  198.     /**
  199.      * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
  200.      *
  201.      * @param pageNo 页号,从1开始.
  202.      * @return 含总记录数和当前页数据的Page对象.
  203.      */
  204.     public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {
  205.         
  206.         return hedao.pagedQuery(criteria, pageNo, pageSize);
  207.     }
  208.     /**
  209.      * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.
  210.      *
  211.      * @param pageNo 页号,从1开始.
  212.      * @return 含总记录数和当前页数据的Page对象.
  213.      */
  214.     public Page pagedQuery(int pageNo, int pageSize, Criterion... criterions) {
  215.         
  216.         return hedao.pagedQuery(pageNo, pageSize, criterions);
  217.     }
  218.     /**
  219.      * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>.
  220.      *
  221.      * @param pageNo 页号,从1开始.
  222.      * @return 含总记录数和当前页数据的Page对象.
  223.      */
  224.     public Page pagedQuery(int pageNo, int pageSize, String orderBy,
  225.             boolean isAsc, Criterion... criterions) {
  226.         
  227.         return hedao.pagedQuery(pageNo, pageSize, orderBy, isAsc, criterions);
  228.     }
  229.     /**
  230.      * 删除对象.
  231.      */
  232.     public void remove(T entity) {
  233.         
  234.        hedao.remove(entity);
  235.     }
  236.     /**
  237.      * 根据ID删除对象.
  238.      */
  239.     public void removeById(PK id) {
  240.         
  241.         hedao.removeById(id);
  242.     }
  243.     /**
  244.      * 保存对象.<br>
  245.      * 如果对象已在本session中持久化了,不做任何事。<br>
  246.      * 如果另一个seesion拥有相同的持久化标识,抛出异常。<br>
  247.      * 如果没有持久化标识属性,调用save()。<br>
  248.      * 如果持久化标识表明是一个新的实例化对象,调用save()。<br>
  249.      * 如果是附带版本信息的(<version>或<timestamp>)且版本属性表明为新的实例化对象就save()。<br>
  250.      * 否则调用update()重新关联托管对象
  251.      */
  252.     public void save(T entity) {
  253.         hedao.save(entity);
  254.     }
  255.     
  256.     /**
  257.      * 在不同的session中关联修改过的托管对象
  258.      */
  259.     public void update(T entity){
  260.         
  261.         hedao.update(entity);
  262.     }
  263. }

IBase.java

  1. /**
  2.  * 
  3.  */
  4. package com.hibernate.dao.base;
  5. import java.io.Serializable;
  6. import java.util.List;
  7. import org.hibernate.Criteria;
  8. import org.hibernate.Query;
  9. import org.hibernate.criterion.Criterion;
  10. import org.springframework.orm.hibernate3.HibernateTemplate;
  11. import com.hibernate.dao.generic.HibernateGenericDao;
  12. import com.hibernate.dao.support.Page;
  13. /**
  14.  * 提供hibernate dao的所有操作,<br>
  15.  * 实现类由spring注入HibernateEntityDao和HibernateGenericDao来实现
  16.  * 
  17.  */
  18. public interface IBaseDao<T,PK extends Serializable> {
  19.     
  20.     /**
  21.      * 获取全部对象
  22.      * 
  23.      * @see HibernateGenericDao#getAll(Class)
  24.      */
  25.     public List<T> getAll();
  26.     
  27.     /**
  28.      * 获取全部对象,带排序参数.
  29.      */
  30.     public List<T> getAll(String orderBy, boolean isAsc);
  31.     
  32.     /**
  33.      * 根据ID移除对象.
  34.      */
  35.     public void removeById(PK id);
  36.     
  37.     /**
  38.      * 取得Entity的Criteria.
  39.      */
  40.     public Criteria createCriteria(Criterion... criterions);
  41.     
  42.     /**
  43.      * 取得Entity的Criteria,带排序参数.
  44.      */
  45.     public Criteria createCriteria(String orderBy, boolean isAsc,
  46.             Criterion... criterions);
  47.     
  48.     /**
  49.      * 根据属性名和属性值查询对象.
  50.      * 
  51.      * @return 符合条件的对象列表
  52.      */
  53.     public List<T> findBy(String propertyName, Object value);
  54.     
  55.     /**
  56.      * 根据属性名和属性值查询对象,带排序参数.
  57.      * 
  58.      * @return 符合条件的对象列表
  59.      */
  60.     public List<T> findBy(String propertyName, Object value, String orderBy,
  61.             boolean isAsc);
  62.     
  63.     /**
  64.      * 根据属性名和属性值查询单个对象.
  65.      * 
  66.      * @return 符合条件的唯一对象 or null
  67.      */
  68.     public T findUniqueBy(String propertyName, Object value);
  69.     
  70.     /**
  71.      * 判断对象某些属性的值在数据库中唯一.
  72.      * 
  73.      * @param uniquePropertyNames
  74.      *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
  75.      * @see HibernateGenericDao#isUnique(Class,Object,String)
  76.      */
  77.     public boolean isUnique(T entity, String uniquePropertyNames);
  78.     
  79.     /**
  80.      * 消除与 Hibernate Session 的关联
  81.      * 
  82.      */
  83.     public void evit(T entity);
  84.     
  85.     
  86.     /**
  87.      * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
  88.      */
  89.     public T get(PK id);
  90.     
  91.     /**
  92.      * 保存对象.
  93.      */
  94.     public void save(T o);
  95.     
  96.     /**
  97.      * 删除对象.
  98.      */
  99.     public void remove(T o);
  100.     
  101.     public void flush();
  102.     
  103.     public void clear();
  104.     
  105.     /**
  106.      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
  107.      * 留意可以连续设置,如下：
  108.      * <pre>
  109.      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
  110.      * </pre>
  111.      * 调用方式如下：
  112.      * <pre>
  113.      *        dao.createQuery(hql)
  114.      *        dao.createQuery(hql,arg0);
  115.      *        dao.createQuery(hql,arg0,arg1);
  116.      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
  117.      * </pre>
  118.      *
  119.      * @param values 可变参数.
  120.      */
  121.     public Query createQuery(String hql, Object... values);
  122.     
  123.     
  124.     /**
  125.      * 根据hql查询,直接使用HibernateTemplate的find函数.
  126.      */
  127.     @SuppressWarnings("unchecked")
  128.     public List find(String hql, Object... values);
  129.     
  130.     /**
  131.      * 分页查询函数，使用hql.
  132.      *
  133.      * @param pageNo 页号,从1开始.
  134.      */
  135.     public Page pagedQuery(String hql, int pageNo, int pageSize, Object... values);
  136.     
  137.     /**
  138.      * @param hql 查询sql
  139.      * @param start 分页从哪一条数据开始
  140.      * @param pageSize 每一个页面的大小
  141.      * @param values 查询条件
  142.      * @return page对象
  143.      */
  144.     public Page dataQuery(String hql, int start, int pageSize, Object... values);
  145.     
  146.     /**
  147.      * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
  148.      *
  149.      * @param pageNo 页号,从1开始.
  150.      * @return 含总记录数和当前页数据的Page对象.
  151.      */
  152.     public Page pagedQuery(Criteria criteria, int pageNo, int pageSize);
  153.     
  154.     /**
  155.      * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.
  156.      *
  157.      * @param pageNo 页号,从1开始.
  158.      * @return 含总记录数和当前页数据的Page对象.
  159.      */
  160.     public Page pagedQuery(int pageNo, int pageSize, Criterion... criterions);
  161.     
  162.     /**
  163.      * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>.
  164.      *
  165.      * @param pageNo 页号,从1开始.
  166.      * @return 含总记录数和当前页数据的Page对象.
  167.      */
  168.     public Page pagedQuery(int pageNo, int pageSize, String orderBy, boolean isAsc,
  169.                Criterion... criterions);
  170.     
  171.     @SuppressWarnings("unchecked")
  172.     public List executeNativeSql(String sql);
  173.     
  174.     public HibernateTemplate getHibernateTemplate();
  175.     
  176.     /**
  177.      * 在不同的session中关联修改过的托管对象
  178.      */
  179.     public void update(T entity);
  180. }

HibernateEntityDao.java

  1. /**
  2.  * 
  3.  */
  4. package com.hibernate.dao.extend;
  5. import java.io.Serializable;
  6. import java.lang.reflect.InvocationTargetException;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. import org.apache.commons.beanutils.PropertyUtils;
  10. import org.hibernate.Criteria;
  11. import org.hibernate.criterion.CriteriaSpecification;
  12. import org.hibernate.criterion.Criterion;
  13. import org.hibernate.criterion.DetachedCriteria;
  14. import org.hibernate.criterion.Order;
  15. import org.hibernate.criterion.Projection;
  16. import org.hibernate.criterion.Projections;
  17. import org.hibernate.criterion.Restrictions;
  18. import org.hibernate.impl.CriteriaImpl;
  19. import org.hibernate.metadata.ClassMetadata;
  20. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  21. import org.springframework.util.Assert;
  22. import org.springframework.util.ReflectionUtils;
  23. import com.hibernate.dao.support.BeanUtils;
  24. import com.hibernate.dao.support.Page;
  25. /**
  26.  * 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类. <p/> 
  27.  * 子类只要在类定义时指定所管理Entity的Class,
  28.  * 即拥有对单个Entity对象的CRUD操作.
  29.  * 
  30.  * @see    继承自spring的HibernateDaoSupport
  31.  */
  32. public class HibernateEntityDao<T,PK extends Serializable> extends HibernateDaoSupport implements IEntityDao<T, PK> {
  33.     protected Class<T> entityClass;// DAO所管理的Entity类型.
  34.     public void setEntityClass(Class<T> type){
  35.         this.entityClass=type;
  36.     }
  37.     /**
  38.      * 在构造函数中将泛型T.class赋给entityClass.
  39.      */
  40.     public HibernateEntityDao() {
  41.         //entityClass = GenericsUtils.getSuperClassGenricType(getClass());
  42.     }
  43.     /**
  44.      * 取得entityClass.JDK1.4不支持泛型的子类可以抛开Class<T> entityClass,重载此函数达到相同效果。
  45.      */
  46.     protected Class<T> getEntityClass() {
  47.         return entityClass;
  48.     }
  49.     
  50.     /**
  51.      * 根据Serializable类型的id获取实体对象<p/>
  52.      * 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
  53.      * @param id
  54.      */
  55.     @SuppressWarnings("unchecked")
  56.     public T get(PK id) {
  57.         
  58.         return (T) getHibernateTemplate().load(getEntityClass(), id);
  59.     }
  60.     
  61.     /**
  62.      * 获取实体类型的全部对象
  63.      */
  64.     @SuppressWarnings("unchecked")
  65.     public List<T> getAll() {
  66.         return (List<T>)(getHibernateTemplate().loadAll(getEntityClass()));
  67.     }
  68.     
  69.     /**
  70.      * 获取全部对象,带排序字段与升降序参数.
  71.      */
  72.     @SuppressWarnings("unchecked")
  73.     public  List<T> getAll(String orderBy, boolean isAsc) {
  74.         Assert.hasText(orderBy);
  75.         if (isAsc)
  76.             return getHibernateTemplate().findByCriteria(
  77.                     DetachedCriteria.forClass(getEntityClass()).addOrder(Order.asc(orderBy)));
  78.         else
  79.             return getHibernateTemplate().findByCriteria(
  80.                     DetachedCriteria.forClass(getEntityClass()).addOrder(Order.desc(orderBy)));
  81.     }
  82.     /**
  83.      * 删除对象.
  84.      */
  85.     public void remove(T entity) {
  86.         getHibernateTemplate().delete(entity);
  87.     }
  88.     /**
  89.      * 根据ID删除对象.
  90.      */
  91.     public void removeById(PK id) {
  92.         
  93.         remove(get(id));
  94.     }
  95.     /**
  96.      * 保存对象.<br>
  97.      * 如果对象已在本session中持久化了,不做任何事。<br>
  98.      * 如果另一个seesion拥有相同的持久化标识,抛出异常。<br>
  99.      * 如果没有持久化标识属性,调用save()。<br>
  100.      * 如果持久化标识表明是一个新的实例化对象,调用save()。<br>
  101.      * 如果是附带版本信息的(<version>或<timestamp>)且版本属性表明为新的实例化对象就save()。<br>
  102.      * 否则调用update()重新关联托管对象
  103.      */
  104.     public void save(T entity) {
  105.        getHibernateTemplate().saveOrUpdate(entity);
  106.     }
  107.     /**
  108.      * 在不同的session中关联修改过的托管对象
  109.      */
  110.     public void update(T entity) {
  111.        getHibernateTemplate().update(entity);
  112.     }
  113.     
  114.     /**
  115.      * 消除与 Hibernate Session 的关联
  116.      * @param entity
  117.      */
  118.     public void evict(T entity) {
  119.         getHibernateTemplate().evict(entity);
  120.     }
  121.     
  122.     /**
  123.      * 创建Criteria对象.
  124.      * @param criterions 可变的Restrictions条件列表
  125.      */
  126.     public  Criteria createCriteria(Criterion... criterions) {
  127.         Criteria criteria = getSession().createCriteria(getEntityClass());
  128.         for (Criterion c : criterions) {
  129.             criteria.add(c);
  130.         }
  131.         return criteria;
  132.     }
  133.     /**
  134.      * 创建Criteria对象，带排序字段与升降序字段.
  135.      */
  136.     public  Criteria createCriteria(String orderBy, boolean isAsc, Criterion... criterions) {
  137.         Assert.hasText(orderBy);
  138.         Criteria criteria = createCriteria(criterions);
  139.         if (isAsc)
  140.             criteria.addOrder(Order.asc(orderBy));
  141.         else
  142.             criteria.addOrder(Order.desc(orderBy));
  143.         return criteria;
  144.     }
  145.     
  146.     /**
  147.      * 根据属性名和属性值查询对象.
  148.      * @return 符合条件的对象列表
  149.      */
  150.     @SuppressWarnings("unchecked")
  151.     public  List<T> findBy(String propertyName, Object value) {
  152.         Assert.hasText(propertyName);
  153.         return createCriteria(Restrictions.eq(propertyName, value)).list();
  154.     }
  155.     
  156.     /**
  157.      * 根据属性名和属性值查询对象,带排序参数.
  158.      */
  159.     @SuppressWarnings("unchecked")
  160.     public  List<T> findBy(String propertyName, Object value, String orderBy, boolean isAsc) {
  161.         Assert.hasText(propertyName);
  162.         Assert.hasText(orderBy);
  163.         return createCriteria(orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
  164.     }
  165.     
  166.     /**
  167.      * 根据属性名和属性值查询唯一对象.
  168.      * @return 符合条件的唯一对象 or null if not found.
  169.      */
  170.     @SuppressWarnings("unchecked")
  171.     public  T findUniqueBy(String propertyName, Object value) {
  172.         Assert.hasText(propertyName);
  173.         return (T) createCriteria(Restrictions.eq(propertyName, value)).uniqueResult();
  174.     }
  175.     
  176.     /**
  177.      * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
  178.      *
  179.      * @param pageNo 页号,从1开始.

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）