关于HibernateTempleate模版-很多代码可以直接使用,是开发人员不可多得选择
2011-08-10 23:09
411 查看
,
1, 实体类查询
public List<T> findAll(Class<T> entityClass) {
return super.getHibernateTemplate().loadAll(entityClass);
}
2, 保存指定实体类
public Serializable save(T entity) {
return super.getHibernateTemplate().save(entity);
}
3, 查找指定PK的一个实体类对象
public T findEnityById(Class<T> entityClass, PK id) {
return (T) super.getHibernateTemplate().get(entityClass, id);
}
4,更新一个实体 需要更新的实体，须包含主键值
public void update(T t) {
super.getHibernateTemplate().update(t);
}
5,查询所有数据的分页集 实体类型信息 开始下标每页记录数
public List<T> findAllByPage(Class<T> entityClass, int start, int limit) {
String hql = "from " + entityClass.getName() + " model";
return this.findAllByHQLPage(hql, null, start, limit);
}
6,含条件的修改数据 ,通常附加一些更新的条件更新的HQL语句参数,可有项目或多项目,代替Hql中的"?"号
public void update(final String hql, final Object[] params) {
// 使用回调接口完成操作
super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Query query = session.createQuery(hql);
System.out.println(hql);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
query.executeUpdate();
return null;
}
});
}
7, /**
* 更新某个实体的-单个属性值
* @param entityClass 需要更新的实体对象类型,
* @param pkName 更新对象的主键名称,主键属性
* @param pkValue 待更新对象的主键值,指定属性的值,表示某行数据被修改
* @param propName 待更新的属性名称,要修改的属性
* @param propValue 待更新的属性值,修改的属性值
public void update(Class<T> entityClass,String pkName,Object pkValue,String propName,Object propValue){
this.update(entityClass, pkName, pkValue, new String[]{propName}, new Object[]{propValue});
}
8, 删除实体id 实体类型信息
public void deleteById(Class<T> entityClass, PK id) {
super.getHibernateTemplate().delete(this.findEnityById(entityClass, id));
}
9, 查找指定PK的一个实体类对象entityClass 实体Class实体PK实体对象
public T findEnityById(Class<T> entityClass, PK id) {
return (T) super.getHibernateTemplate().get(entityClass, id);
}
10，升序 查询所有实体集合entityClass 实体类型信息 查询到的实体对象集合
public List<T> findAllAsc(Class<T> entityClass,String orderProperty) {
return this.findAll_order(entityClass, orderProperty, "asc");
}
11，分页
/**
* 查询所有数据的分页集
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
*/
public List<T> findAllByPage(Class<T> entityClass, int start, int limit) {
String hql = "from " + entityClass.getName() + " model";
return this.findAllByHQLPage(hql, null, start, limit);
}
/**
* 查询所有数据的分页集,并按用户定义方式排序
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
*/
public List<T> findAllByPage_order(Class<T> entityClass,String orderDesc, int start, int limit) {
String hql = "from " + entityClass.getName() + " model order by "+orderDesc;
return this.findAllByHQLPage(hql, null, start, limit);
}
/**
* 分页查找指定属性的实体集合
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByPropertyPage(Class<T> entityClass, String propertyName,
Object propertyValue,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + "= ? ";
return this.findAllByHQLPage(queryString, new Object[]{propertyValue}, start, limit);
}
/**
* 分页查找指定属性的实体集合,并按用户定义方式排序
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByPropertyPage_order(Class<T> entityClass, String propertyName,
Object propertyValue,String orderDesc,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + "=? order by "+orderDesc;
return this.findAllByHQLPage(queryString, new Object[]{propertyValue}, start, limit);
}
/**
* 查找指定属性集集（逻辑与）的实体集合
*
* @param entityClass
* 实体
* @param propertyNames
* 属性名数组
* @param propertyValues
* 属性值数组
* @return 实体集合
*/
public List<T> findAllByPropertiesPage(Class<T> entityClass, String[] propertyNames,
Object[] propertyValues,int start,int limit) {
if (!(propertyNames!=null&&propertyValues!=null&&propertyValues.length==propertyNames.length)) {
throw new RuntimeException("请提供正确的参数值！propertyNames与propertyValues必须一一对应!");
}
String queryString = "from " + entityClass.getName()
+ " as model where " ;
for (int i = 0; i < propertyValues.length; i++) {
queryString += " model."+propertyNames[i]+" = ? ";
if(i != propertyValues.length-1){
queryString += " and ";
}
}
return this.findAllByHQLPage(queryString,propertyValues,start,limit);
}
/**
* 查找指定属性集集（逻辑与）的实体集合,并按用户定义的方式排序
*
* @param entityClass
* 实体
* @param propertyNames
* 属性名数组
* @param propertyValues
* 属性值数组
* @return 实体集合
*/
public List<T> findAllByPropertiesPage_order(Class<T> entityClass, String[] propertyNames,
Object[] propertyValues,String orderDesc,int start,int limit) {
if (!(propertyNames!=null&&propertyValues!=null&&propertyValues.length==propertyNames.length)) {
throw new RuntimeException("请提供正确的参数值！propertyNames与propertyValues必须一一对应!");
}
String queryString = "from " + entityClass.getName()
+ " as model where " ;
for (int i = 0; i < propertyValues.length; i++) {
queryString += " model."+propertyNames[i]+" = ? ";
if(i != propertyValues.length-1){
queryString += " and ";
}
}
queryString += " order by "+orderDesc;
return this.findAllByHQLPage(queryString,propertyValues,start,limit);
}
/**
* 分页方式模糊查找指定属性的实体集合
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByLikePropertyPage(Class<T> entityClass, String propertyName,
String propertyValue,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + " like '%"+propertyValue+"%'";
return this.findAllByHQLPage(queryString, null, start, limit);
}
/**
* 分页方式模糊查找指定属性的实体集合,并按用户指定方式排序
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByLikePropertyPage_order(Class<T> entityClass, String propertyName,
String propertyValue,String orderDesc,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + " like '%"+propertyValue+"%'";
queryString += " order by "+orderDesc;
return this.findAllByHQLPage(queryString, null, start, limit);
}
/**
* 有分页支持的HQL查询
* @param hql 查询用hql语句
* @param params参数列表
* @param start 开始下标
* @param limit 每页记录数
*/
public List<T> findAllByHQLPage(final String hql, final Object[] params,
final int start, final int limit) {
return (List<T>) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(hql);
if (params != null && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
// 表示是分页查询
if (start != -1 && limit != -1) {
query.setFirstResult(start);
query.setMaxResults(limit);
}
return query.list();
}
});
}
/**
* 获得总的记录数
* @param entityClass 实体类的类信信息
* @return 该实体所对应的表中的记录总数
*/
public Long getTotalCount(final Class<T> entityClass) {
return (Long) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
String hql = "select count(o) from "
+ entityClass.getName() + " o";
Query query = session.createQuery(hql);
Object obj = query.uniqueResult();
return obj;
}
});
}
/**
* 带条件的分页记录总数查询
*
* @param hql 查询hql语句
* @param params 参数列表
* @return 满足该条件的记录总数
*/
public Long getTotalCountByHQL(final String hql, final Object[] params) {
return (Long) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(hql);
if (params != null && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
return query.uniqueResult();
}
});
}
/**
* 带条件的分页记录总数查询
*
* @param hql 查询hql语句
* @return 满足该条件的记录总数
*/
public Long getTotalCountByHQL(final String hql) {
return this.getTotalCountByHQL(hql, null);
}
/***************************************************************************
* 以下部分是QBE查询
**************************************************************************/
/**
* 根据模板对象查找对应的所有记录(不分页)
*
* @param entityClass
* 实体类型信息
* @param example
* 查询模板对象
* @return 查询到的记录集
*/
public List<T> findAllByQBE(final Class<T> entityClass, final T example) {
return this.findAllByQBEPage(entityClass, example, -1, -1);
}
/**
* 根据模板对象查找对应的分页记录
*
* @param entityClass
* 实体类型信息
* @param example
* 查询模板对象
* @param start
* 开始记录下标
* @param limit
* 每页记录数
* @return 查询到的分页记录集
*/
public List<T> findAllByQBEPage(final Class<T> entityClass,
final T example, final int start, final int limit) {
return this.findAllByQBEPage(entityClass, example, start, limit, null);
}
/**
* 根据模板对象查找对应的记录(含分页和排序)
*
* @param entityClass
* 实体类型信息
* @param example
* 查询模板对象
* @param start
* 开始记录下标
* @param limit
* 每页记录数
* @param orders
* 自定义排序对象数组
* @return 查询到的分页记录集
*/
public List<T> findAllByQBEPage(final Class<T> entityClass,
final T example, final int start, final int limit,
final Order[] orders) {
return (List<T>) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Example.create(example));
// 设置排序
if (orders != null && orders.length > 0) {
for (int i = 0; i < orders.length; i++) {
criteria.addOrder(orders[i]);
}
}
if (start != -1 && limit != -1) {
criteria.setFirstResult(start);
criteria.setMaxResults(limit);
}
return criteria.list();
}
});
}
/**
* 查询一个统计函数的结果
*
* @param entityClass
* 实体的类型信息
* @param example
* 模板对象
* @param projection
* 聚合函数对象
* @return
*/
public Object getStatisticalValueByQBE(final Class<T> entityClass,
final T example, final Projection projection) {
return super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Example.create(example));
criteria.setProjection(projection);
return criteria.uniqueResult();
}
});
}
/**
* 根据模板对象查找对应的记录的总数
*
* @param entityClass
* 实体类型信息
* @param example
* 模板对象
* @return
*/
public Integer getTotalCountByExample(final Class<T> entityClass, final T example) {
return (Integer) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Example.create(example));
criteria.setProjection(Projections.rowCount());// 总行数
return criteria.uniqueResult();
}
});
}
/***************************************************************************
* 以下是QBC查询
**************************************************************************/
/**
* 最全的QBC查询基础方法
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @param orders 查询后记录的排序条件,由Order对象生成
* @param projs 分组和聚合查询条件
* @param isUniqueResult 是否返回唯一值
* @return
*/
public Object findAllByQBCPage(final Class<T> entityClass, final int start,
final int limit,final Criterion[] criterions,final Order[] orders,
final Projection[] projs, final boolean isUniqueResult) {
return super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
//添加条件
if(criterions!=null&&criterions.length>0){
for (int i = 0; i < criterions.length; i++) {
criteria.add(criterions[i]);
}
}
//添加排序
if(orders!=null&&orders.length>0){
for (int i = 0; i < orders.length; i++) {
criteria.addOrder(orders[i]);
}
}
//添加分组统计
if(projs!=null&&projs.length>0){
for (int i = 0; i < projs.length; i++) {
criteria.setProjection(projs[i]);
}
}
//查看是否要分页
if(start!=-1&&limit!=-1){
criteria.setFirstResult(start);
criteria.setMaxResults(limit);
}
if(isUniqueResult){
return criteria.uniqueResult();
}else{
return criteria.list();
}
}
});
}
/**
* 用QBC查询满足条件的分页记录(分页、排序)
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @param orders 查询后记录的排序条件,由Order对象生成
* @return
*/
public List<T> findAllByQBCPage(final Class<T> entityClass, final int start,
final int limit,final Criterion[] criterions,final Order[] orders) {
return (List<T>) this.findAllByQBCPage(entityClass, start, limit, criterions, orders, null, false);
}
/**
* 用QBC查询满足条件的分页记录(分页)
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @return
*/
public List<T> findAllByQBCPage(final Class<T> entityClass, final int start,
final int limit,final Criterion[] criterions) {
return (List<T>) this.findAllByQBCPage(entityClass, start, limit, criterions, null, null, false);
}
/**
* 用QBC查询满足条件的所有记录(不分页)
* @param entityClass 实体类型信息
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @param orders 查询后记录的排序条件,由Order对象生成
* @return
*/
public List<T> findAllByQBCPage(final Class<T> entityClass,final Criterion[] criterions) {
return (List<T>) this.findAllByQBCPage(entityClass, -1, -1, criterions, null, null, false);
}
/**
* 查询滞QBC条件的记录总数
* @param entityClass 实体类型信息
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @return
*/
public Integer getTotalCountByQBC(final Class<T> entityClass,final Criterion[] criterions){
return (Integer)this.findAllByQBCPage(entityClass, -1, -1, criterions, null,new Projection[]{Projections.rowCount()}, true);
}
1, 实体类查询
public List<T> findAll(Class<T> entityClass) {
return super.getHibernateTemplate().loadAll(entityClass);
}
2, 保存指定实体类
public Serializable save(T entity) {
return super.getHibernateTemplate().save(entity);
}
3, 查找指定PK的一个实体类对象
public T findEnityById(Class<T> entityClass, PK id) {
return (T) super.getHibernateTemplate().get(entityClass, id);
}
4,更新一个实体 需要更新的实体，须包含主键值
public void update(T t) {
super.getHibernateTemplate().update(t);
}
5,查询所有数据的分页集 实体类型信息 开始下标每页记录数
public List<T> findAllByPage(Class<T> entityClass, int start, int limit) {
String hql = "from " + entityClass.getName() + " model";
return this.findAllByHQLPage(hql, null, start, limit);
}
6,含条件的修改数据 ,通常附加一些更新的条件更新的HQL语句参数,可有项目或多项目,代替Hql中的"?"号
public void update(final String hql, final Object[] params) {
// 使用回调接口完成操作
super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Query query = session.createQuery(hql);
System.out.println(hql);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
query.executeUpdate();
return null;
}
});
}
7, /**
* 更新某个实体的-单个属性值
* @param entityClass 需要更新的实体对象类型,
* @param pkName 更新对象的主键名称,主键属性
* @param pkValue 待更新对象的主键值,指定属性的值,表示某行数据被修改
* @param propName 待更新的属性名称,要修改的属性
* @param propValue 待更新的属性值,修改的属性值
public void update(Class<T> entityClass,String pkName,Object pkValue,String propName,Object propValue){
this.update(entityClass, pkName, pkValue, new String[]{propName}, new Object[]{propValue});
}
8, 删除实体id 实体类型信息
public void deleteById(Class<T> entityClass, PK id) {
super.getHibernateTemplate().delete(this.findEnityById(entityClass, id));
}
9, 查找指定PK的一个实体类对象entityClass 实体Class实体PK实体对象
public T findEnityById(Class<T> entityClass, PK id) {
return (T) super.getHibernateTemplate().get(entityClass, id);
}
10，升序 查询所有实体集合entityClass 实体类型信息 查询到的实体对象集合
public List<T> findAllAsc(Class<T> entityClass,String orderProperty) {
return this.findAll_order(entityClass, orderProperty, "asc");
}
11，分页
/**
* 查询所有数据的分页集
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
*/
public List<T> findAllByPage(Class<T> entityClass, int start, int limit) {
String hql = "from " + entityClass.getName() + " model";
return this.findAllByHQLPage(hql, null, start, limit);
}
/**
* 查询所有数据的分页集,并按用户定义方式排序
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
*/
public List<T> findAllByPage_order(Class<T> entityClass,String orderDesc, int start, int limit) {
String hql = "from " + entityClass.getName() + " model order by "+orderDesc;
return this.findAllByHQLPage(hql, null, start, limit);
}
/**
* 分页查找指定属性的实体集合
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByPropertyPage(Class<T> entityClass, String propertyName,
Object propertyValue,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + "= ? ";
return this.findAllByHQLPage(queryString, new Object[]{propertyValue}, start, limit);
}
/**
* 分页查找指定属性的实体集合,并按用户定义方式排序
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByPropertyPage_order(Class<T> entityClass, String propertyName,
Object propertyValue,String orderDesc,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + "=? order by "+orderDesc;
return this.findAllByHQLPage(queryString, new Object[]{propertyValue}, start, limit);
}
/**
* 查找指定属性集集（逻辑与）的实体集合
*
* @param entityClass
* 实体
* @param propertyNames
* 属性名数组
* @param propertyValues
* 属性值数组
* @return 实体集合
*/
public List<T> findAllByPropertiesPage(Class<T> entityClass, String[] propertyNames,
Object[] propertyValues,int start,int limit) {
if (!(propertyNames!=null&&propertyValues!=null&&propertyValues.length==propertyNames.length)) {
throw new RuntimeException("请提供正确的参数值！propertyNames与propertyValues必须一一对应!");
}
String queryString = "from " + entityClass.getName()
+ " as model where " ;
for (int i = 0; i < propertyValues.length; i++) {
queryString += " model."+propertyNames[i]+" = ? ";
if(i != propertyValues.length-1){
queryString += " and ";
}
}
return this.findAllByHQLPage(queryString,propertyValues,start,limit);
}
/**
* 查找指定属性集集（逻辑与）的实体集合,并按用户定义的方式排序
*
* @param entityClass
* 实体
* @param propertyNames
* 属性名数组
* @param propertyValues
* 属性值数组
* @return 实体集合
*/
public List<T> findAllByPropertiesPage_order(Class<T> entityClass, String[] propertyNames,
Object[] propertyValues,String orderDesc,int start,int limit) {
if (!(propertyNames!=null&&propertyValues!=null&&propertyValues.length==propertyNames.length)) {
throw new RuntimeException("请提供正确的参数值！propertyNames与propertyValues必须一一对应!");
}
String queryString = "from " + entityClass.getName()
+ " as model where " ;
for (int i = 0; i < propertyValues.length; i++) {
queryString += " model."+propertyNames[i]+" = ? ";
if(i != propertyValues.length-1){
queryString += " and ";
}
}
queryString += " order by "+orderDesc;
return this.findAllByHQLPage(queryString,propertyValues,start,limit);
}
/**
* 分页方式模糊查找指定属性的实体集合
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByLikePropertyPage(Class<T> entityClass, String propertyName,
String propertyValue,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + " like '%"+propertyValue+"%'";
return this.findAllByHQLPage(queryString, null, start, limit);
}
/**
* 分页方式模糊查找指定属性的实体集合,并按用户指定方式排序
*
* @param entityClass
* 实体
* @param propertyName
* 属性名
* @param value
* 条件
* @return 实体集合
*/
public List<T> findAllByLikePropertyPage_order(Class<T> entityClass, String propertyName,
String propertyValue,String orderDesc,int start,int limit) {
String queryString = "from " + entityClass.getName()
+ " as model where model." + propertyName + " like '%"+propertyValue+"%'";
queryString += " order by "+orderDesc;
return this.findAllByHQLPage(queryString, null, start, limit);
}
/**
* 有分页支持的HQL查询
* @param hql 查询用hql语句
* @param params参数列表
* @param start 开始下标
* @param limit 每页记录数
*/
public List<T> findAllByHQLPage(final String hql, final Object[] params,
final int start, final int limit) {
return (List<T>) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(hql);
if (params != null && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
// 表示是分页查询
if (start != -1 && limit != -1) {
query.setFirstResult(start);
query.setMaxResults(limit);
}
return query.list();
}
});
}
/**
* 获得总的记录数
* @param entityClass 实体类的类信信息
* @return 该实体所对应的表中的记录总数
*/
public Long getTotalCount(final Class<T> entityClass) {
return (Long) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
String hql = "select count(o) from "
+ entityClass.getName() + " o";
Query query = session.createQuery(hql);
Object obj = query.uniqueResult();
return obj;
}
});
}
/**
* 带条件的分页记录总数查询
*
* @param hql 查询hql语句
* @param params 参数列表
* @return 满足该条件的记录总数
*/
public Long getTotalCountByHQL(final String hql, final Object[] params) {
return (Long) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(hql);
if (params != null && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
return query.uniqueResult();
}
});
}
/**
* 带条件的分页记录总数查询
*
* @param hql 查询hql语句
* @return 满足该条件的记录总数
*/
public Long getTotalCountByHQL(final String hql) {
return this.getTotalCountByHQL(hql, null);
}
/***************************************************************************
* 以下部分是QBE查询
**************************************************************************/
/**
* 根据模板对象查找对应的所有记录(不分页)
*
* @param entityClass
* 实体类型信息
* @param example
* 查询模板对象
* @return 查询到的记录集
*/
public List<T> findAllByQBE(final Class<T> entityClass, final T example) {
return this.findAllByQBEPage(entityClass, example, -1, -1);
}
/**
* 根据模板对象查找对应的分页记录
*
* @param entityClass
* 实体类型信息
* @param example
* 查询模板对象
* @param start
* 开始记录下标
* @param limit
* 每页记录数
* @return 查询到的分页记录集
*/
public List<T> findAllByQBEPage(final Class<T> entityClass,
final T example, final int start, final int limit) {
return this.findAllByQBEPage(entityClass, example, start, limit, null);
}
/**
* 根据模板对象查找对应的记录(含分页和排序)
*
* @param entityClass
* 实体类型信息
* @param example
* 查询模板对象
* @param start
* 开始记录下标
* @param limit
* 每页记录数
* @param orders
* 自定义排序对象数组
* @return 查询到的分页记录集
*/
public List<T> findAllByQBEPage(final Class<T> entityClass,
final T example, final int start, final int limit,
final Order[] orders) {
return (List<T>) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Example.create(example));
// 设置排序
if (orders != null && orders.length > 0) {
for (int i = 0; i < orders.length; i++) {
criteria.addOrder(orders[i]);
}
}
if (start != -1 && limit != -1) {
criteria.setFirstResult(start);
criteria.setMaxResults(limit);
}
return criteria.list();
}
});
}
/**
* 查询一个统计函数的结果
*
* @param entityClass
* 实体的类型信息
* @param example
* 模板对象
* @param projection
* 聚合函数对象
* @return
*/
public Object getStatisticalValueByQBE(final Class<T> entityClass,
final T example, final Projection projection) {
return super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Example.create(example));
criteria.setProjection(projection);
return criteria.uniqueResult();
}
});
}
/**
* 根据模板对象查找对应的记录的总数
*
* @param entityClass
* 实体类型信息
* @param example
* 模板对象
* @return
*/
public Integer getTotalCountByExample(final Class<T> entityClass, final T example) {
return (Integer) super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Example.create(example));
criteria.setProjection(Projections.rowCount());// 总行数
return criteria.uniqueResult();
}
});
}
/***************************************************************************
* 以下是QBC查询
**************************************************************************/
/**
* 最全的QBC查询基础方法
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @param orders 查询后记录的排序条件,由Order对象生成
* @param projs 分组和聚合查询条件
* @param isUniqueResult 是否返回唯一值
* @return
*/
public Object findAllByQBCPage(final Class<T> entityClass, final int start,
final int limit,final Criterion[] criterions,final Order[] orders,
final Projection[] projs, final boolean isUniqueResult) {
return super.getHibernateTemplate().executeWithNativeSession(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
//添加条件
if(criterions!=null&&criterions.length>0){
for (int i = 0; i < criterions.length; i++) {
criteria.add(criterions[i]);
}
}
//添加排序
if(orders!=null&&orders.length>0){
for (int i = 0; i < orders.length; i++) {
criteria.addOrder(orders[i]);
}
}
//添加分组统计
if(projs!=null&&projs.length>0){
for (int i = 0; i < projs.length; i++) {
criteria.setProjection(projs[i]);
}
}
//查看是否要分页
if(start!=-1&&limit!=-1){
criteria.setFirstResult(start);
criteria.setMaxResults(limit);
}
if(isUniqueResult){
return criteria.uniqueResult();
}else{
return criteria.list();
}
}
});
}
/**
* 用QBC查询满足条件的分页记录(分页、排序)
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @param orders 查询后记录的排序条件,由Order对象生成
* @return
*/
public List<T> findAllByQBCPage(final Class<T> entityClass, final int start,
final int limit,final Criterion[] criterions,final Order[] orders) {
return (List<T>) this.findAllByQBCPage(entityClass, start, limit, criterions, orders, null, false);
}
/**
* 用QBC查询满足条件的分页记录(分页)
* @param entityClass 实体类型信息
* @param start 开始下标
* @param limit 每页记录数
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @return
*/
public List<T> findAllByQBCPage(final Class<T> entityClass, final int start,
final int limit,final Criterion[] criterions) {
return (List<T>) this.findAllByQBCPage(entityClass, start, limit, criterions, null, null, false);
}
/**
* 用QBC查询满足条件的所有记录(不分页)
* @param entityClass 实体类型信息
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @param orders 查询后记录的排序条件,由Order对象生成
* @return
*/
public List<T> findAllByQBCPage(final Class<T> entityClass,final Criterion[] criterions) {
return (List<T>) this.findAllByQBCPage(entityClass, -1, -1, criterions, null, null, false);
}
/**
* 查询滞QBC条件的记录总数
* @param entityClass 实体类型信息
* @param criterions 查询条件数组，由Restrictions对象生成，如Restrictions.like("name","%x%")等;
* @return
*/
public Integer getTotalCountByQBC(final Class<T> entityClass,final Criterion[] criterions){
return (Integer)this.findAllByQBCPage(entityClass, -1, -1, criterions, null,new Projection[]{Projections.rowCount()}, true);
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 关于HibernateTempleate模版-很多代码可以直接使用,是开发人员不可多得选择
- 在xml布局文件中，我们既可以设置px，也可以设置dp（或者dip）。一般情况下，我们都会选择使用dp，这样可以保证不同屏幕分辨率的机器上布局一致。但是在代码中，如何处理呢？很多控件的方法中都只提供了
- 【特别报道：关于国津软件的某对手ITSM产品使用的“开源框架+剽窃国津代码”之开发模式】 （注：“国聿软件公司”名称变更为“国津软件公司”之后，“国聿”成为国津软件公司的一个注册商标品牌.） 我们
- Git 远程仓库(Github) Git 并不像 SVN 那样有个中心服务器。 目前我们使用到的 Git 命令都是在本地执行，如果你想通过 Git 分享你的代码或者与其他开发人员合作。 你就需要
- WINDOWS下客户端，服务器端代码，可以直接copy使用
- Eclipse使用技巧 - 自定义JavaDoc注解和代码模版，提升开发效率和规范性
- Hibernate 框架编写增、删、改、查接口源码（可以作为模版代码）
- genexus 中可以直接使用java代码
- hibernate使用myeclise简化开发----根据数据库及表反向生成代码信息
- 使用 satis 搭建一个私有的 Composer 包仓库 在我们的日常php开发中可能需要使用大量的composer包，大部份都可以直接使用，但在公司内部总有一小部份包是不能公开的，这时候我们就需
- 利用Volley框架开发实战（快速开发，代码直接可以用在实战中...）
- MyPage从Page派生，MyPage总有一个Label控件。以便以后从MyPage派生的页都可以直接使用Label？给个代码例子看看？
- 用java实现验证码的生成，以下代码是一个controller，可以直接使用!
- 是否能直接使用img对象名字来替代images[索引值]数组呢？测试代码显示：可以。
- 搜集了一段播放用java播放.wav的代码，可以直接使用
- Windows 硬件开发人员怎样选择代码签名证书类型
- 在VC++项目中使用.Net库，经过简单转换，可以直接使用C#代码
- springboot中通用mapper结合mybatis generator的使用 通用mapper是为了方便开发人员对单表进行crud操作而产生的一套通用方法。 通用mapper只支持单表操作，可以
- 关于选择参加人员的返回代码以及工作汇报的sql