通用DAO

import java.io.Serializable;
import java.util.List;
import java.util.Map;

@SuppressWarnings("unchecked")
public interface GenericDao<T,ID extends Serializable> {

/**
* 根据id加载实体,没有返回
* @param id
* @return
*/
T get(ID id);

/**
* 没有则抛出异常
* @param id
* @return
*/

T load(ID id);

/**
* 保存实体
* @param entity
* @return
*/
void save(T entity);

/**
* 更新实体
* @param entity
*/
void update(T entity);

/**
* 删除实体
* @param entity
*/
void delete(T entity);

/**
* 根据ID删除数据
* @param id
*/
void deleteById(ID id);

/**
* 得到所有的实体
* @return
*/
List<T> findAll();

/**
* 得到所有实体记录
* @return
*/
int count();

/**
* 根据hql得到记录集
* @param hql
* @param params
* @return
*/
List<T> findByHql(final String hql,Object...params);

/**
* 根据hql得到查询记录数
* @param hql
* @param params
* @return
*/
int countByHql(final String hql,Object...params);


/**
* 同步缓存和数据库
*/
public void flush();

public void clear();

/**
* 排序方法
* @param entityClass 实体类型
* @param orderBy 按什么排序
* @param isAsc true为升序
* @return
*/
public List<T> getAll(Class<T> entityClass, String orderBy, boolean isAsc);

/**
* 如果没有定义泛型或想查找其它实体数据可用此方法
* 根据属性分页查询
* @param entityClass 实体类型
* @param propertyMap 属性和值数据
* @param currentPage 当前页
* @param pageSize 每页页数
* @param orderBy 排序字段
* @param isAsc 排序方式
* @return
*/
public List<T> findAll(Class<T> entityClass,Map<String,Object> propertyMap,int currentPage,int pageSize,String orderBy,boolean isAsc);

/**
* 得到有属性值的记录数,非泛型可用
* @param entityClass
* @param propertyMap
* @return
*/
public int count(Class<T> entityClass,Map<String,Object> propertyMap);

/**
* 得到有属性值的记录数已定义泛型可用
* @param entityClass
* @param propertyMap
* @return
*/
public int count(Map<String,Object> propertyMap);


/**
* 根据相关的带参数hql计算总数,无参数values设为null
* @param hql
* @param values
* @return
*/
public int count(String hql,Object[] values);


/**
* 根据hql删除数据
* @return 返回删除条数
* @param hql
*/
public int delete(String hql);

/**
* 自定义查询
* @param filter
* @return
*/
public List<T> findAllBy(Map filter);

}


------------------------------------------------------------


import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

@SuppressWarnings("unchecked")
public abstract class AbstractHibernateDao<T,ID extends Serializable> extends HibernateDaoSupport
implements GenericDao<T, ID> {

Class<T> presistentClass;

public AbstractHibernateDao(){
presistentClass = (Class<T>)((ParameterizedType)this.getClass().
getGenericSuperclass()).getActualTypeArguments()[0];
}

public T get(ID id) {
return (T)this.getHibernateTemplate().get(presistentClass, id);
}



public T load(ID id) {
return (T) this.getHibernateTemplate().load(presistentClass, id);
}

public void save(T entity) {
this.getHibernateTemplate().save(entity);
}

public void update(T entity) {
this.getHibernateTemplate().update(entity);
}

public void delete(T entity) {
this.getHibernateTemplate().delete(entity);
}

public void deleteById(ID id) {
this.getHibernateTemplate().delete(get(id));
}

public List<T> findAll() {
return this.getHibernateTemplate().find("from " + presistentClass.getName());
}

public int count() {

return 0;
}

public List<T> findByHql(String hql, Object... params) {
this.getHibernateTemplate().find(hql, params);
return null;
}

public int countByHql(final String hql, final Object... params) {

int count = 0;

StringBuffer countHql = new StringBuffer();
countHql.append("SELECT COUNT(*) AS CNT FROM (");
countHql.append(hql);
countHql.append(")");

@SuppressWarnings("unchecked")
List<Object> list = getHibernateTemplate().find(countHql.toString(),params);
if (list != null) {
count = Integer.parseInt(list.get(0).toString());
}
list = null;
return count;
}

public void flush() {
this.getHibernateTemplate().flush();
}

public void clear() {
getHibernateTemplate().clear();
}

/**
* 获取全部对象,带排序字段与升降序参数.
*/
public List<T> getAll(String orderBy, boolean isAsc) {
if (isAsc)
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(presistentClass).addOrder(Order.asc(orderBy)));
else
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(presistentClass).addOrder(Order.desc(orderBy)));

}


public List<T> findBy(final String propertyName, final Object value, final String orderBy, final boolean isAsc){
return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(getPresistentClass());
criteria.add(Restrictions.eq(propertyName, value));
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
return criteria.list();
}

});
}


public List<T> findAll(final Class<T> entityClass,final Map<String,Object> propertyMap,final int currentPage,final int pageSize,final String orderBy,final boolean isAsc) {
return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
criteria.add(Restrictions.allEq(propertyMap));
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
criteria.setFirstResult((currentPage - 1) * pageSize);
criteria.setMaxResults(pageSize);
return criteria.list();
}

});
}

public List<T> findAll(final Map propertyMap,final int currentPage,final int pageSize,final String orderBy,final boolean isAsc) {
return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(getPresistentClass());
criteria.add(Restrictions.allEq(propertyMap));
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
criteria.setFirstResult((currentPage - 1) * pageSize);
criteria.setMaxResults(pageSize);
return criteria.list();
}

});
}

public int count(Class<T> entityClass,Map<String,Object> propertyMap) {
int size = 0;
StringBuilder hql = new StringBuilder(" SELECT COUNT(*) AS CNT FROM ");
hql.append(entityClass.getName());
hql.append(contactPropertyMap(propertyMap));
List list = this.getHibernateTemplate().find(hql.toString());

if (list != null) {
size = Integer.parseInt(list.get(0).toString());
}
return size;
}

public int count(Map propertyMap) {
int size = 0;
StringBuilder hql = new StringBuilder(" SELECT COUNT(*) AS CNT FROM ");
hql.append(getPresistentClass().getName());
hql.append(contactPropertyMap(propertyMap));
List list = this.getHibernateTemplate().find(hql.toString());

if (list != null) {
size = Integer.parseInt(list.get(0).toString());
}
return size;
}






public int count(String hql, Object[] values) {
StringBuilder tempHql = new StringBuilder();
tempHql.append(" SELECT COUNT(*) AS CNT FROM ( ");
tempHql.append(hql);
tempHql.append(")");

List list = getHibernateTemplate().find(tempHql.toString(), values);

int size = 0;
if (list != null) {
size = Integer.parseInt(list.get(0).toString());
}
return size;
}

public List<T> findAll(final String hql,final Object[] values,
final int currentPage, final int pageSize) {
return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(hql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values);
}
query.setFirstResult((currentPage - 1) * pageSize);
query.setMaxResults(pageSize);
return query.list();
}

});
}

public List<T> getAll(final Class<T> entityClass, final String orderBy, final boolean isAsc) {
return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Class clazz = entityClass;

if (clazz == null) {
clazz = getPresistentClass();
}
Criteria criteria = session.createCriteria(clazz);

if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
return criteria.list();
}

});
}

public Class<T> getPresistentClass() {
return presistentClass;
}

public void setPresistentClass(Class<T> presistentClass) {
this.presistentClass = presistentClass;
}

public final String contactPropertyMap(Map<String,Object> propertyMap) {
StringBuilder sql = new StringBuilder(" WHERE 1 = 1 ");
Set<Map.Entry<String,Object>> mapSet = propertyMap.entrySet();
Iterator iterator = mapSet.iterator();
while(iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
sql.append(" AND ");
sql.append(entry.getKey());
sql.append("=");
sql.append("'");
sql.append(entry.getValue());
sql.append("'");

}
return sql.toString();
}

public int delete(String hql) {
return getHibernateTemplate().bulkUpdate(hql);
}







}