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