接口类
import java.io.Serializable;实现类
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import org.hibernate.criterion.DetachedCriteria;
import xxxxx.bean.Page;
public interface BaseDao {
/**
* 是否存在指定条件数据。
* @param entityClass 映射类
* @param whereClause 条件
* @param values 条件值
* @return true:存在，false:不存在
*/
public boolean isExist(Class<?> entityClass,String whereClause, Map<String, Object> params );
/**
* 执行update,delete,insert语句。
* @param hql
*
* @return 执行影响的数量
*/
public int execute(final String hql, final Map<String, Object> params);
/**
* 持久化
* @param entity
*/
public void save(Object entity);
/**
* 更新
* @param entity
*/
public void update(Object entity);
/**
* 保存或更新。
* @param entity
*/
public void saveOrUpdate(Object entity);
/**
* 删除操作。
* @param entity
*/
public void delete(Object entity);
/**
* 按照属性(id)条件查找数据。
* @param clasz 待查找的实体类
* @param id 根据条件id的值匹配实体类的id
* @return E 查找到的实体
*/
public <E> E getById(Class<E> clasz, Serializable id);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param includes 条件参数
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String[] includes);
/**
* 根据条件查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, String[] includes);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 条件参数
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数条件
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String[] includes);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params, String order);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象
* @param args 参数
* @param order 排序条件
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String order, String[] includes);
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param start 分页开始条数
* @param limit 分页每页显示条数
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String order, int start, String[] includes) ;
/**
* 查找全部实体类信息。
* @param clasz 待查找的实体类
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz) ;
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String[] includes) ;
/**
* 根据条件查找符合条件全部实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions);
/**
* 根据条件查找符合条件全部实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象）
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
String[] includes) ;
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions, Map<String, Object> params) ;
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String[] includes);
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @return E 查找到的实体
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String order) ;
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param includes 需要关联取出的外键对象）
* @return E 查找到的实体
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String order, String[] includes) ;
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param limit 分页每页显示条数
* @return E 查找到的实体
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String order, int limit);
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件 （如"id desc,code"）
* @param limit 分页每页显示条数
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String order, int limit, String[] includes);
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param start 分页开始条数
* @param limit 分页每页显示条数
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体
*/
public <E> List<E> findAll(final Class<E> clasz, final String conditions, final Map<String, Object> params, final String order, final int start, final int limit, final String[] includes);
/**
* 根据条件查找第一个符合条件实体类信息。
* @param clasz 待查找的实体类
* @param hql hql语句
* @param args 参数
* @return E 查找到的实体（List集合）
*/
public <E> E findFirstByHQL(Class<E> clasz, final String hql, final Map<String, Object> params) ;
/**
* HQL查询根据条件查找符合条件实体类信息。
* @param clasz 待查找的实体类
* @param hql hql语句（必须完整写出 from Class）
* @param args hql 条件（Object数组）
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findByHQL(Class<E> clasz, final String hql, final Map<String, Object> params) ;
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return Integer 标量值
*/
public Integer findInt(String hql, Map<String, Object> params);
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return Long 标量值
*/
public Long findLong(String hql, Map<String, Object> params);
/**
* 标量
* 根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return Double 标量值
*/
public Double findDouble(String hql, Map<String, Object> params) ;
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return BigDecimal 标量值
*/
public BigDecimal findBigDecimal(String hql, Map<String, Object> params);
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return String 标量值
*/
public String findString(String hql, Map<String, Object> params);
/**
* 分页条件查询
* @param DetachedCriteria dc 条件
* @param start 分页开始显示数
* @param limit 分页每页显示条数
* @return Page 分页对象
*/
public <E> Page<E> findPage(final DetachedCriteria dc, final int start,
final int limit) ;
public <T> Page<T> findPageByHQL(Class<T> clasz, final String hql, final Map<String, Object> params,
final int start, final int limit) ;
/**
* 根据hql语句查找实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 参数
* @param start 分页开始显示数
* @param limit 分页每页显示条数
* @return page 分页对象
*/
public <T> Page<T> findPageBySQL(final Class<T> clasz,final String sql, final Map<String, Object> params,final int start, final int limit) ;
/**
* 根据hql语句查找实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 参数
* @param count_sql
* @param start 分页开始显示数
* @param limit 分页每页显示条数
* @return page 分页对象
*/
public <T> Page<T> findPageBySQL(final Class<T> clasz,final String sql,String count_sql, final Map<String, Object> params,final int start, final int limit) ;
/**
* 根据hql语句查找实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 条件参数
* @return List 集合
*/
public List<?> findListBySQL(final String sql,final Map<String, Object> params);
/**
* 根据hql语句查找第一个实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 条件 参数
* @return Object
*/
public Object findFirstBySQL(final String sql, final Map<String, Object> params);
/**
* SQL查询并将结果集自动转换成POJO的list
* @param clazz 最终转换成的类
* @param sql 查询条件
* @return
*/
public <T> List<T> findObjListBySql(final Class<T> clazz,final String sql);
/**
* SQL查询并将结果集自动转换成POJO的list
* @param clazz 最终转换成的类
* @param sql 查询条件
* @return
*/
public <T> List<T> findObjListBySql(final Class<T> clazz,final String sql,final Integer start,final Integer limit);
}
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.internal.CriteriaImpl;
import org.hibernate.transform.ResultTransformer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import xxxxx.bean.Page;
import xxxxx.dao.BaseDao;
import xxxxx.framework.constant.SystemConstant;
import xxxxx.util.CustomResultTransformer;
import xxxxx.util.DaoHelper;
import xxxxx.util.ReflectionUtils;
@Repository
public class BaseDaoImpl implements BaseDao{
@Autowired
private SessionFactory sessionFactory;
/**
* 获得当前事物的session
*
* @return org.hibernate.Session
*/
public Session getCurrentSession() {
return this.sessionFactory.getCurrentSession();
}
/**
* 是否存在指定条件数据。
* @param entityClass 映射类
* @param whereClause 条件
* @param values 条件值
* @return true:存在，false:不存在
*/
public boolean isExist(Class<?> entityClass,String whereClause, Map<String, Object> params ) {
String selectHql = "select count(id) from "+ entityClass.getName() + " where " + whereClause;
return findLong(selectHql, params) > 0;
}
/**
* 执行update,delete,insert语句。
* @param hql
*
* @return 执行影响的数量
*/
public int execute(final String hql, final Map<String, Object> params) {
Query query = this.getCurrentSession().createQuery(hql);
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
return query.executeUpdate();
}
@Override
public void delete(Object entity) {
this.getCurrentSession().delete(entity);
}
/**
* 持久化
* @param entity
*/
public void save(Object entity) {
this.getCurrentSession().save(entity);
}
/**
* 更新
* @param entity
*/
public void update(Object entity) {
this.getCurrentSession().update(entity);
}
/**
* 保存或更新。
* @param entity
*/
public void saveOrUpdate(Object entity) {
this.getCurrentSession().saveOrUpdate(entity);
}
/**
* 按照属性(id)条件查找数据。
* @param clasz 待查找的实体类
* @param id 根据条件id的值匹配实体类的id
* @return E 查找到的实体
*/
public <E> E getById(Class<E> clasz, Serializable id) {
return (E) this.getCurrentSession().get(clasz, id);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz) {
return findFirst(clasz, null, null, null, 0, null);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param includes 条件参数
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String[] includes) {
return findFirst(clasz, null, null, null, 0, includes);
}
/**
* 根据条件查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions) {
return findFirst(clasz, conditions, null, null, 0, null);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, String[] includes) {
return findFirst(clasz, conditions, null, null, 0, includes);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 条件参数
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params) {
return findFirst(clasz, conditions, params, null, 0, null);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数条件
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String[] includes) {
return findFirst(clasz, conditions, params, null, 0, includes);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String order) {
return findFirst(clasz, conditions, params, order, 0, null);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象
* @param args 参数
* @param order 排序条件
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String order, String[] includes) {
return findFirst(clasz, conditions, params, order, 0, includes);
}
/**
* 查找某实体类的第一条记录。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param start 分页开始条数
* @param limit 分页每页显示条数
* @return E 查找到的实体
*/
public <E> E findFirst(Class<?> clasz, String conditions, Map<String, Object> params,
String order, int start, String[] includes) {
List<E> results = (List<E>) findAll(clasz, conditions, params, order, start, 1,includes);
return results.size() == 0 ? null : results.get(0);
}
/**
* 查找全部实体类信息。
* @param clasz 待查找的实体类
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz) {
return findAll(clasz, null, null, null, 0, 0, null);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String[] includes) {
return findAll(clasz, null, null, null, 0, 0, includes);
}
/**
* 根据条件查找符合条件全部实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions) {
return findAll(clasz, conditions, null, null, 0, 0, null);
}
/**
* 根据条件查找符合条件全部实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param includes 需要关联取出的外键对象）
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
String[] includes) {
return findAll(clasz, conditions, null, null, 0, 0, includes);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions, Map<String, Object> params) {
return findAll(clasz, conditions, params, null, 0, 0, null);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String[] includes) {
return findAll(clasz, conditions, params, null, 0, 0, includes);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @return E 查找到的实体
*/
public <E> List<E> findAll(Class<E> clasz, String conditions, Map<String, Object> params, String order) {
return findAll(clasz, conditions, params, order, 0, 0, null);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param includes 需要关联取出的外键对象）
* @return E 查找到的实体
*/
public <E> List<E> findAll(Class<E> clasz, String conditions, Map<String, Object> params, String order, String[] includes) {
return findAll(clasz, conditions, params, order, 0, 0, includes);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param limit 分页每页显示条数
* @return E 查找到的实体
*/
public <E> List<E> findAll(Class<E> clasz, String conditions, Map<String, Object> params, String order, int limit) {
return findAll(clasz, conditions, params, order, limit, 0, null);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件 （如"id desc,code"）
* @param limit 分页每页显示条数
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findAll(Class<E> clasz, String conditions,
Map<String, Object> params, String order, int limit, String[] includes) {
return findAll(clasz, conditions, params, order, 0, limit, includes);
}
/**
* 根据条件查找全部符合条件实体类信息。
* @param clasz 待查找的实体类
* @param conditions 条件
* @param args 参数
* @param order 排序条件（如"id desc,code"）
* @param start 分页开始条数
* @param limit 分页每页显示条数
* @param includes 需要关联取出的外键对象
* @return E 查找到的实体
*/
public <E> List<E> findAll(final Class<E> clasz, final String conditions, final Map<String, Object> params, final String order, final int start, final int limit, final String[] includes) {
String hql = "from " + clasz.getName() + " as e";
if (includes != null && includes.length > 0) {
for (String je : includes) {
hql += " left outer join fetch e." + je + " as " + (je.replaceAll("\\.", "")) + " ";
}
}
if (StringUtils.isNotEmpty(conditions)) {
hql += " where (" + DaoHelper.insertAlias(conditions, clasz) + ")";
}
if (StringUtils.isNotEmpty(order))
hql += " order by e." + order;
Query query = this.getCurrentSession().createQuery(hql);
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
return query.setFirstResult(start).setMaxResults((limit == 0 ? Integer.MAX_VALUE : limit)).list();
}
/**
* 根据条件查找第一个符合条件实体类信息。
* @param clasz 待查找的实体类
* @param hql hql语句
* @param args 参数
* @return E 查找到的实体（List集合）
*/
public <E> E findFirstByHQL(Class<E> clasz, final String hql, final Map<String, Object> params) {
Query query = this.getCurrentSession().createQuery(hql);
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
List<?> list = query.setFirstResult(0).setMaxResults(1).list();
return (list != null && list.size() > 0 )? (E)list.get(0) : null;
}
/**
* HQL查询根据条件查找符合条件实体类信息。
* @param clasz 待查找的实体类
* @param hql hql语句（必须完整写出 from Class）
* @param args hql 条件（Object数组）
* @return E 查找到的实体（List集合）
*/
public <E> List<E> findByHQL(Class<E> clasz, final String hql, final Map<String, Object> params) {
Query query = this.getCurrentSession().createQuery(hql);
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
return query.list();
}
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return Integer 标量值
*/
public Integer findInt(String hql, Map<String, Object> params) {
Integer intValue = findFirstByHQL(Integer.class, hql, params);
return intValue == null ? 0 : intValue;
}
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return Long 标量值
*/
public Long findLong(String hql, Map<String, Object> params) {
Long longValue = findFirstByHQL(Long.class, hql, params);
return longValue == null ? 0L : longValue;
}
/**
* 标量
* 根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return Double 标量值
*/
public Double findDouble(String hql, Map<String, Object> params) {
Double doubleValue = findFirstByHQL(Double.class, hql, params);
return doubleValue == null ? 0.00 : doubleValue;
}
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return BigDecimal 标量值
*/
public BigDecimal findBigDecimal(String hql, Map<String, Object> params) {
BigDecimal bigDecimalValue = findFirstByHQL(BigDecimal.class, hql, params);
return bigDecimalValue == null ? new BigDecimal(0) : bigDecimalValue;
}
/**
* 标量
* HQL查询根据条件查找符合条件第一个标量值。
* @param hql hql语句
* @param args 参数
* @return String 标量值
*/
public String findString(String hql, Map<String, Object> params) {
String stringValue = findFirstByHQL(String.class, hql, params);
return stringValue;
}
/**
* 分页条件查询
* @param DetachedCriteria dc 条件
* @param start 分页开始显示数
* @param limit 分页每页显示条数
* @return Page 分页对象
*/
public <E> Page<E> findPage(final DetachedCriteria dc, final int start, final int limit) {
Criteria c = dc.getExecutableCriteria(this.getCurrentSession());
CriteriaImpl impl = (CriteriaImpl) c;
Projection projection = impl.getProjection();
ResultTransformer transformer = impl.getResultTransformer();
List<CriteriaImpl.OrderEntry> orderEntries = (List<CriteriaImpl.OrderEntry>) ReflectionUtils.getFieldValue(impl, "orderEntries");
ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList<CriteriaImpl.OrderEntry>());
// 执行Count查询
c.setResultTransformer(CriteriaImpl.DISTINCT_ROOT_ENTITY);
long total = (Long) c.setProjection(Projections.countDistinct("id")).uniqueResult();
// 将之前的Projection和OrderBy条件重新设回去
c.setProjection(projection);
c.setResultTransformer(transformer);
ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
c.setFirstResult(start);
c.setMaxResults(limit);
List<E> list = c.list();
return new Page<E>(start, limit, Integer.parseInt(String.valueOf(total)),(list == null ? new ArrayList() : list));
}
public <T> Page<T> findPageByHQL(Class<T> clasz, final String hql, final Map<String, Object> params, final int start, final int limit) {
String countQueryString = "select count (*) " + DaoHelper.removeSelect(DaoHelper.removeOrders(hql));
Long count = params ==null ? findLong(countQueryString, null):findLong(countQueryString, params);
Query query = this.getCurrentSession().createQuery(hql);
// 参数组装
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
List<?> list = query.setFirstResult(start).setMaxResults(limit).list();
return new Page(start, limit,count.intValue(),list);
}
/**
* 根据hql语句查找实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 参数
* @param start 分页开始显示数
* @param limit 分页每页显示条数
* @return page 分页对象
*/
public <T> Page<T> findPageBySQL(final Class<T> clasz,final String sql, final Map<String, Object> params,final int start, final int limit) {
Query query = this.getCurrentSession().createSQLQuery(sql);
// 参数组装
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
// 结果转换
query.setResultTransformer(new CustomResultTransformer(clasz));
List<?> list = query.setFirstResult(start).setMaxResults(limit).list();
String countQueryString = "select count (*) " + DaoHelper.removeSelect(DaoHelper.removeOrders(sql));
Object o = findFirstBySQL(countQueryString,params);
Long count = 0L;
if(o!=null&&o instanceof BigDecimal){
count = ((BigDecimal)o).longValue();
}else if(o!=null){
count= Long.valueOf(String.valueOf(o));
}
else{
count = 0L;
}
return new Page(start, limit,count.intValue(),list);
}
/**
* 根据hql语句查找实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 参数
* @param count_sql
* @param start 分页开始显示数
* @param limit 分页每页显示条数
* @return page 分页对象
*/
public <T> Page<T> findPageBySQL(final Class<T> clasz,final String sql,String count_sql, final Map<String, Object> params,final int start, final int limit) {
Query query = this.getCurrentSession().createSQLQuery(sql);
// 参数组装
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
// 结果转换
query.setResultTransformer(new CustomResultTransformer(clasz));
List<T> list = query.setFirstResult(start).setMaxResults(limit).list();
Long count = (Long)findFirstBySQL(count_sql, params);
return new Page(start, limit,count.intValue(),list);
}
/**
* 根据hql语句查找实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 条件参数
* @return List 集合
*/
public List<?> findListBySQL(final String sql,final Map<String, Object> params) {
Query query = this.getCurrentSession().createSQLQuery(sql);
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
return query.list();
}
/**
* 根据hql语句查找第一个实体信息
* @param sql createSQLQuery条件（hql语句)
* @param args 条件 参数
* @return Object
*/
public Object findFirstBySQL(final String sql, final Map<String, Object> params) {
Query query = this.getCurrentSession().createSQLQuery(sql);
if ((params != null) && !params.isEmpty()) {
for (String key : params.keySet()) {
query.setParameter(key, params.get(key));
}
}
List<?> list = query.setFirstResult(0).setMaxResults(1).list();
return (list != null && list.size() > 0 ? list.get(0) : null);
}
/**
* SQL查询并将结果集自动转换成POJO的list
* @param clazz 最终转换成的类
* @param sql 查询条件
* @return
*/
public <T> List<T> findObjListBySql(final Class<T> clazz,final String sql){
Query query = this.getCurrentSession().createSQLQuery(sql);
query.setResultTransformer(new CustomResultTransformer(clazz));
return query.list();
}
/**
* SQL查询并将结果集自动转换成POJO的list
* @param clazz 最终转换成的类
* @param sql 查询条件
* @return
*/
public <T> List<T> findObjListBySql(final Class<T> clazz,final String sql,final Integer start,final Integer limit){
Query query = this.getCurrentSession().createSQLQuery(sql).setFirstResult(start==null?0:start).setMaxResults(limit==null?SystemConstant.DEFAULT_PAGE_SIZE:limit);
query.setResultTransformer(new CustomResultTransformer(clazz));
return query.list();
}