hibernategenericdao.java

来自「anewssystem新闻发布系统集成使用了spring hibernate f」· Java 代码 · 共 648 行 · 第 1/2 页

        // Count查询
        String countQueryString = " select count (*) "
            + removeSelect(removeOrders(hql));
        List countlist = getHibernateTemplate()
                             .find(countQueryString, values);
        long totalCount = (Long) countlist.get(0);

        if (totalCount < 1) {
            return new Page();
        }

        // 实际查询返回分页对象
        int startIndex = Page.getStartOfPage(pageNo, pageSize);
        Query query = createQuery(hql, values);
        List list = query.setFirstResult(startIndex).setMaxResults(pageSize)
                         .list();

        return new Page(startIndex, totalCount, pageSize, list);
    }

    /**
     * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.
     *
     * @param criteria 查询条件
     * @param pageNo 页号,从1开始
     * @param pageSize 每页包含多少条记录
     * @return 含总记录数和当前页数据的Page对象
     */
    public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {
        Assert.notNull(criteria);
        Assert.isTrue(pageNo >= 1, "pageNo should start from 1");

        CriteriaImpl impl = (CriteriaImpl) criteria;

        // 先把Projection和OrderBy条件取出来,清空两者来执行Count操作
        Projection projection = impl.getProjection();
        List<CriteriaImpl.OrderEntry> orderEntries;

        try {
            orderEntries = (List) BeanUtils.forceGetProperty(impl,
                    "orderEntries");
            BeanUtils.forceSetProperty(impl, "orderEntries",
                new ArrayList());
        } catch (NoSuchFieldException e) {
            throw new InternalError(
                " Runtime Exception impossibility throw ");
        } catch (IllegalAccessException e) {
            throw new InternalError(
                " Runtime Exception impossibility throw ");
        }

        // 执行查询
        int totalCount = (Integer) criteria.setProjection(Projections
                .rowCount()).uniqueResult();

        // 将之前的Projection和OrderBy条件重新设回去
        criteria.setProjection(projection);

        if (projection == null) {
            criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
        }

        try {
            BeanUtils.forceSetProperty(impl, "orderEntries", orderEntries);
        } catch (NoSuchFieldException e) {
            throw new InternalError(
                " Runtime Exception impossibility throw ");
        } catch (IllegalAccessException e) {
            throw new InternalError(
                " Runtime Exception impossibility throw ");
        }

        // 返回分页对象
        if (totalCount < 1) {
            return new Page();
        }

        int startIndex = Page.getStartOfPage(pageNo, pageSize);
        List list = criteria.setFirstResult(startIndex)
                            .setMaxResults(pageSize).list();

        return new Page(startIndex, totalCount, pageSize, list);
    }

    /**
     * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.
     *
     * @param entityClass 实体类型
     * @param pageNo 页号,从1开始
     * @param pageSize 每页包含多少条记录
     * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)}
     * @return 含总记录数和当前页数据的Page对象
     */
    public Page pagedQuery(Class entityClass, int pageNo, int pageSize,
        Criterion... criterions) {
        Criteria criteria = createCriteria(entityClass, criterions);

        return pagedQuery(criteria, pageNo, pageSize);
    }

    /**
     * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>.
     *
     * @param entityClass 实体类型
     * @param pageNo 页号,从1开始
     * @param pageSize 每页包含多少条记录
     * @param orderBy 排序字段
     * @param isAsc 是否正序
     * @param criterions 可变的Restrictions条件列表,见{@link #createQuery(String,Object...)}
     * @return 含总记录数和当前页数据的Page对象
     */
    public Page pagedQuery(Class entityClass, int pageNo, int pageSize,
        String orderBy, boolean isAsc, Criterion... criterions) {
        Criteria criteria = createCriteria(entityClass, orderBy, isAsc,
                criterions);

        return pagedQuery(criteria, pageNo, pageSize);
    }

    /**
     * 判断对象某些属性的值在数据库中是否唯一.
     *
     * @param entityClass 实体类型
     * @param entity 判断的对象
     * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
     * @param <T> 实体类型
     * @return 是否唯一
     */
    public <T> boolean isUnique(Class<T> entityClass, Object entity,
        String uniquePropertyNames) {
        Assert.hasText(uniquePropertyNames);

        Criteria criteria = createCriteria(entityClass)
                                .setProjection(Projections.rowCount());
        String[] nameList = uniquePropertyNames.split(",");

        try {
            // 循环加入唯一列
            for (String name : nameList) {
                logger.fatal(name);
                logger.fatal(PropertyUtils.getProperty(entity, name));
                criteria.add(Restrictions.eq(name,
                        PropertyUtils.getProperty(entity, name)));
            }

            // 以下代码为了如果是update的情况,排除entity自身.
            String idName = getIdName(entityClass);

            // 取得entity的主键值
            Serializable id = getId(entityClass, entity);

            // 如果id!=null,说明对象已存在,该操作为update,加入排除自身的判断
            if (id != null) {
                criteria.add(Restrictions.not(Restrictions.eq(idName, id)));
            }
        } catch (NoSuchMethodException e) {
            ReflectionUtils.handleReflectionException(e);
        } catch (IllegalAccessException e) {
            ReflectionUtils.handleReflectionException(e);
        } catch (InvocationTargetException e) {
            ReflectionUtils.handleReflectionException(e);
        }

        logger.fatal(criteria);
        logger.fatal(criteria.uniqueResult());

        return (Integer) criteria.uniqueResult() == 0;
    }

    /**
     * 取得对象的主键值,辅助函数.
     *
     * @param entityClass 实体类型
     * @param entity 实体对象
     * @return 返回主键值
     * @throws NoSuchMethodException 如果没有id的getter方法
     * @throws IllegalAccessException 如果没有权限访问
     * @throws InvocationTargetException 如果调用过程出错
     */
    public Serializable getId(Class entityClass, Object entity)
        throws NoSuchMethodException, IllegalAccessException,
            InvocationTargetException {
        Assert.notNull(entity);
        Assert.notNull(entityClass);

        return (Serializable) PropertyUtils.getProperty(entity,
            getIdName(entityClass));
    }

    /**
     * 取得对象的主键名,辅助函数.
     *
     * @param clazz 类型
     * @return 主键字段名称
     */
    public String getIdName(Class clazz) {
        Assert.notNull(clazz);

        ClassMetadata meta = getSessionFactory().getClassMetadata(clazz);
        Assert.notNull(meta,
            "Class " + clazz + " not define in hibernate session factory.");

        String idName = meta.getIdentifierPropertyName();
        Assert.hasText(idName,
            clazz.getSimpleName() + " has no identifier property define.");

        return idName;
    }

    /**
     * 去除hql的select 子句，未考虑union的情况,用于pagedQuery.
     *
     * @see #pagedQuery(String,int,int,Object[])
     *
     * @param hql 原始查询语句
     * @return 删除掉select子句的查询语句
     */
    private static String removeSelect(String hql) {
        Assert.hasText(hql);

        int beginPos = hql.toLowerCase(Locale.CHINA).indexOf("from");
        Assert.isTrue(beginPos != -1,
            " hql : " + hql + " must has a keyword 'from'");

        return hql.substring(beginPos);
    }

    /**
     * 去除hql的orderby 子句，用于pagedQuery.
     *
     * @see #pagedQuery(String,int,int,Object[])
     *
     * @param hql 原始查询语句
     * @return 删除掉select子句的查询语句
     */
    private static String removeOrders(String hql) {
        Assert.hasText(hql);

        Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",
                Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(hql);
        StringBuffer sb = new StringBuffer();

        while (m.find()) {
            m.appendReplacement(sb, "");
        }

        m.appendTail(sb);

        return sb.toString();
    }

    /**
     * 消除与 Hibernate Session 的关联.
     * @param entity 实体对象
     */
    public void evit(Object entity) {
        getHibernateTemplate().evict(entity);
    }

    /**
     * 获得完成初始化的实体beans.
     *
     * @param clz 类型
     * @param id 主键
     * @param <T> 实体类型
     * @return T 实体bean
     */
    public <T> T initialize(Class<T> clz, Serializable id) {
        T entity = get(clz, id);
        Hibernate.initialize(entity);

        return entity;
    }

    /**
     * 获得总数.
     * @param clz 实体类
     * @param <T> 实体类型
     * @return count
     */
    public <T> Long getCount(Class<T> clz) {
        Criteria c = getSession().createCriteria(clz)
                         .setProjection(Projections.rowCount());

        return (Long) c.uniqueResult();
    }

    /**
     * 获得总数.
     * @param clz 实体类
     * @param name 字段名称
     * @param value 字段值
     * @param <T> 实体类型
     * @return count
     */
    public <T> Long getCount(Class<T> clz, String name, Object value) {
        Criteria c = getSession().createCriteria(clz)
                         .add(Restrictions.eq(name, value))
                         .setProjection(Projections.rowCount());

        return (Long) c.uniqueResult();
    }

    /**
     * 获得总数.
     * @param hql 查询语句
     * @return count
     */
    public Long getCount(String hql) {
        return (Long) getHibernateTemplate().find(hql).get(0);
    }

    /**
     * 获得总数.
     * @param hql 查询语句
     * @param values 参数
     * @return count
     */
    public Long getCount(String hql, Object... values) {
        return (Long) getHibernateTemplate().find(hql, values).get(0);
    }
}