hibernate常用增删改查接口实现

/**
 * 作者：宫长明
 * 
 */


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

import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;

@SuppressWarnings("unchecked")
public interface IBaseDao<T,PK extends Serializable> {
    /**
     * 保存PO对象
     * @param obj PO所要保存值对象
     * @return 保存记录数 0：为保存失败
     * */
    public void save(T obj);
    /**
     * 保存PO对象
     * @param obj PO所要保存值对象
     * @return 保存记录数 0：为保存失败
     * */
    public void saveByObj(T obj);
    
    /**
     * 保存多个PO对象，将PO封装到List中
     * @param obj PO所要保存值对象
     * @return 保存记录数 0：为保存失败
     * */
    public void save(List<T> ls);
    
    /**
     * 删除表中所有数据,通过Object.ClassName得到表名称
     * @param tableName删除表名称
     * @return 删除记录数据
     * */
    public int deleteAll(String tableName);
    
    public void deleteById(PK id);
    
    /**  
     * 根据查询语句，返回对象列表  
     *   
     * @param hql  
     *            查询语句  
     * @return 符合查询语句的对象列表 
     */  
    public List find(String hql);
    
    /**  
     * 返回指定起始位置，指定条数的对象  
     *   
     * @param hql  
     *            查询语句  
     * @param firstResult  
     *            起始位置  
     * @param maxResults  
     *            最多纪录数  
     * @return list 结果列表  
     */  
    //public List<T> find(String hql,int firstResult,int maxResults);
    
    /**  
     * 返回指定起始位置，指定条数的对象  
     *   
     * @param hql  
     *            查询语句  
     * @param pageNo  
     *            页数  
     * @return list 结果列表  
     */  
    public List<T> find(String hql,int pageNo,int maxResults);
    
    /**  
     * 查询语句需要的条件参数。通过map传递  
     *   
     * @param hql  
     *            查询语句  
     * @param map  
     *            参数  
     * @param firstResult  
     *            起始位置  
     * @param maxResults  
     *            最多纪录数  
     * @return list 结果列表  
     */  
    //public List<T> find(String hql, Map map, int firstResult,int maxResults);
    
    /**  
     * 查询语句需要的条件参数。通过map传递  
     *   
     * @param hql  
     *            查询语句  
     * @param map  
     *            参数  
     * @param pageNo  
     *            页数 
     */  
    public List<T> find(String hql, Map map, int pageNo,int maxResults);
    
    /**  
     * 根据查询语句，返回对象列表  
     *   
     * @param hql  
     *            查询语句  
     * @return 符合查询语句的对象列表 
     */  
    public List<T> find(String hql, Map map);
    
    
    /**  
     * 通过Hql 执行update/delete操作  
     *   
     * @param hql  
     * @return  
     */  
    public int executeUpdate(String hql);
    
    /**  
     * 查询表中所有记录  
     */ 
    public List<T> findAll() ;
    
    /**  
     * 通过 DetachedCriteria 进行查询指定查询条数
     * @param firstResult  
     *            起始位置  
     * @param maxResults  
     *            最多纪录数 
     * @param dc 
     * 
     * @return 符合查询语句的对象列表
     */  
    public List<T> findByCriteria(DetachedCriteria dc,int firstResult, int maxResults);
    
    /**
     * 统计符合查询语句的条数
     * @param dc 
     * */
    public int countByCriteria(DetachedCriteria dc);
    
    /**  
     * 通过Hql 执行update/delete操作 带条件查询
     *   
     * @param hql  
     * @return  
     */ 
    public int executeUpdate(String hql, Map pMap);
    
    /**
     * 删除obj指定ID记录,通过捕捉异常来判断是否删除成功
     * @param obj 指定ID记录数
     * */
    public void delete(T obj);
    
    /**
     * 根据ID从内存中加载记录
     * @param aclass 类
     * @param id 可以为任意类型
     * */
    public T load(PK id) ;
    
    /**
     * 加载数据
     * */
    public T get(PK id);
    
    public Object getObj(Class cls,PK id);
    
    /**
     * 保存或修改
     * @param obj 保存对象
     * */
    public void saveOrUpdate(T obj);
    
    public void saveOrUpdate(List<T> lsj);
    /**
     * 更新记录
     * @param obj 保存对象
     * */
    public void update(T obj);
    /**
     * 更新记录
     * @param obj 保存对象
     * */
    public int update(String hql);
    /**  
     * TODO count hql 方法 . 带条件 
     */  
    public int count(String hql, Map params);
    
    /**  
     * TODO count hql 方法
     */  
    public Integer count(String hql);
    
    /**
     * 根据hql删除记录
     * @param hql 删除语句
     * @param map 条件参数
     * @return 删除条数
     * */
    public int delete(String hql,Map map);
    
    /**
     * 根据hql删除记录
     * @param hql 删除语句
     * @param map 条件参数
     * @return 删除条数
     * */
    public int delete(String hql);
    
    /**
     * 根据hql语句，更新记录部分字段
     * @param hql 更新语句
     * @param map 更新参数及条件
     * @return 返回值大于0则更新成功，否则更新失败
     * */
    public int update(String hql,Map map);
    
    /**
     * 返回Object List数组
     * @param hql
     * @param map        hql中的参数和参数值
     * @param pageNo     页码
     * @param maxResults 每页显示最大条数
     * @return
     */
    public List findObj( String hql, Map map, int pageNo, int maxResults);
    
    /**
     * 返回Object List数组
     * @param hql
     * @return
     */
    public List findObj( String hql);
    
    /**
     * 返回Object List数组
     * @param hql
     * @param map        hql中的参数和参数值
     * @return
     */
    public List findObj( String hql, Map map);
    
    /**
     * 
     * @功能描述： 查询
     * @param firstResult首条数据位数
     * @param maxResult  每次取出最大条数
     * @param criterion
     * @return
     * @throws DataAccessException   
     * @return：List<T> 
     * @创建人：宫长明
     * @创建时间：May 28, 2010 4:14:31 PM
     */
    public List<T> findByCriteria( int firstResult,  int maxResults,  Criterion... criterion) ;
    
    /**
     * 
     * @功能描述： 查义
     * @param firstResult   首条查询位置
     * @param maxResults    第次查询最大数  小于0查询所有
     * @param sortProperty  排序字段
     * @param ascend        排序方法  true: ASC fasle: DESC
     * @param criterion     
     * @return   
     * @return：List<T> 
     * @创建人：宫长明
     * @创建时间：May 28, 2010 4:14:37 PM
     */
    public List<T> findByCriteria( int firstResult,  int maxResults,  String sortProperty,  boolean ascend,  Criterion... criterion);
    
    /**
     * 
     * @功能描述： 
     * @param criterion
     * @return
     * @throws DataAccessException   
     * @return：List<T> 
     * @创建人：宫长明
     * @创建时间：May 28, 2010 4:14:41 PM
     */
    public List<T> findByCriteria( Criterion...criterion); 
    //throws DataAccessException;
    
    /**
     * 
     * @功能描述： 
     * @param criterion
     * @return
     * @throws DataAccessException   
     * @return：int 
     * @创建人：宫长明
     * @创建时间：May 28, 2010 4:14:45 PM
     */
    public int countByCriteria( Criterion... criterion) ;
    
    /**
     * @功能描述： 根据List删除数据
     * @param obj List<T>
     * @创建人：宫长明
     * @创建时间：2011-4-8 上午09:15:05
     */
    public void deleteByList(List<T> obj);
    
    /**
     * @功能描述： 合并重复obj后保存或添加
     * @param obj
     * @创建人：王树峰
     * @创建时间：2011-4-8 下午03:19:03
     */
    public void saveOrUpdateMerge(T obj);
    
    /**
     * 
    * @Title: saveOrUpdateClear 
    * @Description: 多了一句话.clear()
    * @return： void
    * @param：
    * @throws
     */
    public void saveOrUpdateClear(T obj);
    
    public T mergeObj(T obj);
}

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

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;


/**
 * 
 * @类描述：  Hibernate Dal 基本方法
 * @创建人：宫长明   
 * @创建时间：May 28, 2010 4:11:57 PM  
 * @项目名：办公用品  
 * @版本信息：V 1.0  
 * @Copyright (c) 北京开诚阳光科技有限公司-版权所有 V 2010.0
 */
@SuppressWarnings("unchecked")
public class BaseDaoHibernate<T,PK extends Serializable> extends HibernateDaoSupport implements IBaseDao<T,PK>{
    
    private final Class<T> aclass;
    
    
    public BaseDaoHibernate(){
        this.aclass = (Class<T>)((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public int count(final String hql,final Map mparams) {
        
        List tempList = this.getHibernateTemplate().executeFind(new HibernateCallback(){
            public List doInHibernate(Session session) throws HibernateException, SQLException {
                
                StringBuffer countQuery = new StringBuffer("select count(*) ");
                countQuery.append(hql);
                Query query = session.createQuery(countQuery.toString());
                String params[] = query.getNamedParameters();
                for(int i=0;i<params.length;i++){
                    query.setParameter(params[i], mparams.get(params[i]));
                }
                List result = query.list();
                return result;
            }
        });
        
        Object obj = tempList!=null&&tempList.size()>0?tempList.get(0):0;
        if (obj instanceof Long) {
            Integer count =    Integer.valueOf(String.valueOf(obj));
            return count;
        }else{
            Integer count = Integer.valueOf(String.valueOf(obj));
            return count.intValue();
        }
    }

    public Integer count(String hql) {
        List<Object> result = getHibernateTemplate().find("select count(*) "+hql);
        Object obj = result.get(0);
        if(obj instanceof Integer){
            Integer count =    (Integer)obj;
            return count;
        }else{
            Long count = (Long)obj;
            return count.intValue();
        }
    }

    public int countByCriteria(DetachedCriteria dc) {
        
        return 0;
    }

    public void delete(final T obj) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                session.clear();
                session.delete(obj);
                return null;
            }

        });
    }
    
    public void deleteByList(final List<T> obj) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                session.clear();
                for(T t:obj){
                    session.delete(t);
                }
                return null;
            }
            
        });
    }

    public int deleteAll(final String tableName) {
        
        StringBuffer hql = new StringBuffer("delete from ");
        hql.append(tableName);
        return executeUpdate(hql.toString());
    }

    public int executeUpdate(final String hql) {
        
        Object obj = getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                int result = 0 ; 
                result = query.executeUpdate();
                getHibernateTemplate().flush();
                return result;
            }
        });
        if(obj!=null)
            return ((Integer)obj).intValue();
        else
            return 0;
    }

    public int executeUpdate(final String hql,final Map pMap) {
        
        Object obj = getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                String params[] = query.getNamedParameters();
                for(int i=0;i<params.length;i++){
                    query.setParameter(params[i], pMap.get(params[i]));
                }
                int result = 0;
                result = query.executeUpdate();
                getHibernateTemplate().flush();
                return result;
            }
        });
        if(obj!=null)
            return ((Integer)obj).intValue();
        else
            return 0;
    }

    public List<T> find(final String hql) {
        return getHibernateTemplate().find(hql);
    }
    
    public List<T> findObj(final String hql) {
        return getHibernateTemplate().find(hql);
    }

    public List<T> find(final String hql, final Map map) {
        return getHibernateTemplate().executeFind(new HibernateCallback(){
            public List<T> doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                String[] pamars = query.getNamedParameters();  
                for(int i=0;i<pamars.length;i++){
                    query.setParameter(pamars[i], map.get(pamars[i]));
                }
                List<T> results = new ArrayList();
                results = query.list();
                return results;
            }
        });
    }
    
    public List findObj(final String hql, final Map map) {
        return getHibernateTemplate().executeFind(new HibernateCallback(){
            public List<T> doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                String[] pamars = query.getNamedParameters();  
                for(int i=0;i<pamars.length;i++){
                    query.setParameter(pamars[i], map.get(pamars[i]));
                }
                List<T> results = new ArrayList();
                results = query.list();
                return results;
            }
        });
    }

    public List<T> findAll() throws DataAccessException {
        return findByCriteria();
    }
    
    public List<T> findByCriteria(DetachedCriteria dc, int firstResult, int maxResults) {
        return null;
    }

    public T get(PK id) {
        return (T)getHibernateTemplate().get(aclass, id);
    }
    
    public Object getObj(Class cls,PK id) {
        return (T)getHibernateTemplate().get(cls, id);
    }

    public T load(PK id) throws DataAccessException {
        
        return (T)getHibernateTemplate().load(aclass, id);
    }

    public void save(T obj) {//1
        
        this.getHibernateTemplate().save(obj);
    }
    
    public void saveByObj(T obj) {
        
        this.getHibernateTemplate().save(obj);
    }

    public void save(List<T> ls) {
        
        this.getHibernateTemplate().saveOrUpdateAll(ls);
        getHibernateTemplate().flush();
    }

    public void saveOrUpdateMerge(T obj)
    {
        obj=(T)this.getHibernateTemplate().merge(obj);
        this.getHibernateTemplate().saveOrUpdate(obj);
        getHibernateTemplate().flush();
        getHibernateTemplate().clear();
    }
    
    public void saveOrUpdate(T obj) {
        this.getHibernateTemplate().saveOrUpdate(obj);
        getHibernateTemplate().flush();
    }
    
    public void saveOrUpdateClear(T obj) {
        this.getHibernateTemplate().saveOrUpdate(obj);
        getHibernateTemplate().flush();
        getHibernateTemplate().clear();
    }
    public void saveOrUpdate(List<T> lsj) {
        this.getHibernateTemplate().saveOrUpdateAll(lsj);
        getHibernateTemplate().flush();
    }

    public void update(T obj) {
        this.getHibernateTemplate().update(obj);
        getHibernateTemplate().flush();
    }
    
    public HibernateTemplate getHibTemplate(){
        return this.getHibernateTemplate();
    }

    public int delete(String hql, Map map) {
        return executeUpdate(hql, map);
    }

    public int update(String hql, Map map) {
        return executeUpdate(hql, map);
    }

    public int update(String hql) {
        return executeUpdate(hql);
    }

    public int delete(String hql) {
        return executeUpdate(hql);
    }
    
    public List<T> find(final String hql,final int pageNo,final int maxResults) {
        return getHibernateTemplate().executeFind(new HibernateCallback(){
            public List<T> doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                if(maxResults>0)
                    query.setFirstResult((pageNo-1)*maxResults).setMaxResults(maxResults);
                List<T> results = query.list();
                return results;
            }
        });
    }
    
    public List<T> find(final String hql,final Map map,final int pageNo,final int maxResults) {
        return getHibernateTemplate().executeFind(new HibernateCallback(){
            public List<T> doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                String[] pamars = query.getNamedParameters();  
                for(int i=0;i<pamars.length;i++){
                    query.setParameter(pamars[i], map.get(pamars[i]));
                }
                if(maxResults>0)
                    query.setFirstResult((pageNo-1)*maxResults).setMaxResults(maxResults);
                List<T> results = new ArrayList();
                results = query.list();
                return results;
            }
        });
    }
    
    public List findObj(final String hql,final Map map,final int pageNo,final int maxResults) {
        
        return getHibernateTemplate().executeFind(new HibernateCallback(){
            public List<T> doInHibernate(Session session) throws HibernateException, SQLException {
                
                Query query = session.createQuery(hql);
                String[] pamars = query.getNamedParameters();  
                for(int i=0;i<pamars.length;i++){
                    query.setParameter(pamars[i], map.get(pamars[i]));
                }
                if(maxResults>0)
                    query.setFirstResult((pageNo-1)*maxResults).setMaxResults(maxResults);
                List<T> results = new ArrayList();
                results = query.list();
                return results;
            }
        });
    }

    public void deleteById(final PK id) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                session.delete(session.get(aclass, id));
                return null;
            }

        });
    }
    
    public List<T> findByCriteria(final int firstResult, final int maxResults, final Criterion... criterion) throws DataAccessException{
        return findByCriteria(firstResult, maxResults, null, false, criterion);
    }
    
    public List<T> findByCriteria(final int firstResult, final int maxResults, final String sortProperty, final boolean ascend, final Criterion... criterion){
        return getHibernateTemplate().executeFind(new HibernateCallback(){
            public List<T> doInHibernate(Session session) throws HibernateException, SQLException {
                Criteria crit = session.createCriteria(aclass);
                if(criterion != null){
                    for(Criterion c : criterion){
                        crit.add(c);
                    }
                }
                if(firstResult > 0)
                    crit.setFirstResult(firstResult);
                if(maxResults > 0)
                    crit.setMaxResults(maxResults);
                if(sortProperty != null && sortProperty.trim().length() > 0){
                    crit.addOrder(ascend ? Order.asc(sortProperty) : Order.desc(sortProperty));
                }
                return crit.list();
            }

        });
    }
    
    public List<T> findByCriteria(final Criterion...criterion) throws DataAccessException {
        return findByCriteria(-1, -1, criterion);
    }
    
    public Criteria getCriteria(){
        return this.getSession().createCriteria(aclass);
    }
    
    public int countByCriteria(final Criterion... criterion) throws DataAccessException{
        Object obj = getHibernateTemplate().execute(new HibernateCallback(){
            public Integer doInHibernate(Session session) throws HibernateException, SQLException {
                Criteria crit = session.createCriteria(aclass);
                for(Criterion c : criterion){
                    crit.add(c);
                }
                crit.setProjection(Projections.rowCount());
                Integer total = (Integer)crit.uniqueResult();
                return total;
            }

        });
        if(obj!=null)
            return (Integer)obj;
        return 0;
    }
    
     public T mergeObj(T obj){
         return (T)this.getSession().merge(obj);
     }
}