GenericHibernateDao3

// -------------------- HSQL ----------------------------------------------
    
     // 使用HSQL语句直接增加、更新、删除实体
     public int bulkUpdate(String queryString)
     {
         return getHibernateTemplate().bulkUpdate(queryString);
     }

     // 使用带参数的HSQL语句增加、更新、删除实体
     public int bulkUpdate(String queryString, Object[] values)
     {
         return getHibernateTemplate().bulkUpdate(queryString, values);
     }

     // 使用HSQL语句检索数据
     public List find(String queryString)
     {
         return getHibernateTemplate().find(queryString);
     }

     // 使用带参数的HSQL语句检索数据
     public List find(String queryString, Object[] values)
     {
         return getHibernateTemplate().find(queryString, values);
     }

     // 使用带命名的参数的HSQL语句检索数据
     public List findByNamedParam(String queryString, String[] paramNames, Object[] values)
     {
         return getHibernateTemplate().findByNamedParam(queryString, paramNames, values);
     }

     // 使用命名的HSQL语句检索数据
     public List findByNamedQuery(String queryName)
     {
         return getHibernateTemplate().findByNamedQuery(queryName);
     }

     // 使用带参数的命名HSQL语句检索数据
     public List findByNamedQuery(String queryName, Object[] values)
     {
         return getHibernateTemplate().findByNamedQuery(queryName, values);
     }

     // 使用带命名参数的命名HSQL语句检索数据
     public List findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)
     {
         return getHibernateTemplate().findByNamedQueryAndNamedParam(queryName, paramNames, values);
     }

     // 使用HSQL语句检索数据，返回 Iterator
     public Iterator iterate(String queryString)
     {
         return getHibernateTemplate().iterate(queryString);
     }

     // 使用带参数HSQL语句检索数据，返回 Iterator
     public Iterator iterate(String queryString, Object[] values)
     {
         return getHibernateTemplate().iterate(queryString, values);
     }

     // 关闭检索返回的 Iterator
     public void closeIterator(Iterator it)
     {
         getHibernateTemplate().closeIterator(it);
     }

     // -------------------------------- Criteria ------------------------------
    
     // 创建与会话无关的检索标准
     public DetachedCriteria createDetachedCriteria()
     {
         return DetachedCriteria.forClass( this .entityClass);
     }
    
     // 创建与会话绑定的检索标准
     public Criteria createCriteria()
     {
         return this .createDetachedCriteria().getExecutableCriteria( this .getSession());
     }

     // 检索满足标准的数据
     public List findByCriteria(DetachedCriteria criteria)
     {
         return getHibernateTemplate().findByCriteria(criteria);
     }
    
     // 检索满足标准的数据，返回指定范围的记录
     public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults)
     {
         return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults);
     }

     // 使用指定的实体及属性检索（满足除主键外属性＝实体值）数据
     public List < T > findEqualByEntity(T entity, String [] propertyNames)
     {
         Criteria criteria = this .createCriteria();
         Example exam = Example.create(entity);
         exam.excludeZeroes();
         String [] defPropertys = getSessionFactory().getClassMetadata(entityClass).getPropertyNames();
         for (String defProperty : defPropertys)
         {
             int ii = 0 ;
             for (ii = 0 ; ii < propertyNames.length; ++ ii)
             {
                 if (defProperty.equals(propertyNames[ii]))
                 {
                     criteria.addOrder(Order.asc(defProperty));
                     break ;
                 }
             }
             if (ii == propertyNames.length)
             {
                 exam.excludeProperty(defProperty);
             }
         }
         criteria.add(exam);
         return (List < T > ) criteria.list();
     }
    
     // 使用指定的实体及属性检索（满足属性 like 串实体值）数据
     public List < T > findLikeByEntity(T entity, String [] propertyNames)
     {
         Criteria criteria = this .createCriteria();
         for (String property : propertyNames)
         {
             try
             {
                 Object value = PropertyUtils.getProperty(entity, property);
                 if (value instanceof String)
                 {
                     criteria.add(Restrictions.like(property, (String) value, MatchMode.ANYWHERE));
                     criteria.addOrder(Order.asc(property));
                 }
                 else
                 {
                     criteria.add(Restrictions.eq(property, value));
                     criteria.addOrder(Order.asc(property));
                 }
             }
             catch (Exception ex)
             {
                 // 忽略无效的检索参考数据。
             }
         }
         return (List