,
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);
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public Entity create(Entity entity) throws DaoException {
try
{
getHibernateTemplate().save(entity);
return
entity;
} catch
(DataAccessException e) {
throw new
DaoException("保存
" + entity.getClass().getName()
+ " 实例到数据库失败", e);
}
}
public
void
update(Entity
entity)throws DaoException {
try
{
getHibernateTemplate().update(entity);
} catch
(DataAccessException e) {
throw new
DaoException("更新
" + entity.getClass().getName()
+ " 实例到数据库失败", e);
}
}
public
void
delete(Entity
entity)throws DaoException {
try
{
getHibernateTemplate().delete(entity);
} catch
(DataAccessException e) {
throw new
DaoException("从数据库删除
" + entity.getClass().getName()
+ " 实例失败", e);
}
}
public
void
deleteAll(Class
clazz)throws DaoException {
try
{
List result =
getHibernateTemplate().loadAll(clazz);
getHibernateTemplate().deleteAll(result);
} catch
(DataAccessException e) {
log.error("从数据库删除
" + clazz.getName() +
"的所有记录失败", e);
throw new
DaoException("从数据库删除
" + clazz.getName() +
"的所有记录失败", e);
}
}
public
void
deleteAll(Collection
entities)throws DaoException {
try
{
getHibernateTemplate().deleteAll(entities);
} catch(DataAccessException
e) {
throw new DaoException(e);
}
}
public
Object
loadByKey(Class clazz,String keyName, Object keyValue)
throws
DaoException {
try
{
List result =
getHibernateTemplate().find(
"from " + clazz.getName() + " where " + keyName + " = ?",
keyValue);
if
(result != null
&& result.size() >
0) {
return
result.get(0);
} else
{
return
null;
}
} catch
(DataAccessException e) {
throw new
DaoException("加载
" + keyName + "为 " + keyValue
+ "的 "
+ clazz.getName() + " 实例失败",
e);
}
}
public
List
loadAll(Class
clazz)throws DaoException {
try
{
return
getHibernateTemplate().loadAll(clazz);
} catch
(DataAccessException e) {
throw new
DaoException("加载所有
" + clazz.getName() +
"实例时失败", e);
}
}
public
List find(String queryString)
throws
DaoException {
try
{
return
getHibernateTemplate().find(queryString);
} catch
(DataAccessException e) {
throw new
DaoException("执行查询
" + queryString + "失败", e);
}
}
public
List find(String queryString, Object param) throws DaoException {
try
{
return
getHibernateTemplate().find(queryString, param);
} catch
(DataAccessException e) {
throw new
DaoException("执行参数为
" + param + "的查询 " +
queryString
+ " 失败", e);
}
}
public
List find(String queryString, Object[] params)
throws
DaoException {
try
{
return
getHibernateTemplate().find(queryString, params);
} catch
(DataAccessException e) {
StringBuffer
paramString = newStringBuffer("");
for
(int i
= 0; i < params.length; i++) {
paramString.append(params[i]);
paramString.append(" ");
}
throw new
DaoException("执行参数为
" + paramString + "的查询"
+ queryString + " 失败", e);
}
}
public
List
findByNamedQuery(String
queryName)throws DaoException {
try
{
return
getHibernateTemplate().findByNamedQuery(queryName);
} catch
(DataAccessException e) {
throw new
DaoException("执行命名为
" + queryName + "的查询失败");
}
}
public
List
findByNamedQuery(String queryName,Object param)
throws
DaoException {
try
{