基于hibernate的BaseDAO接口

BaseDao.java

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

import com.xxx.finance.utils.HibernateHandler;
import com.xxx.finance.utils.Pagination;

public interface BaseDao {

    /**
     * 保存实体
     * 
     * @param entity
     *            实体对象
     * @return 实体主键
     */
    Object save(Object entity);

    /**
     * 
     * 删除实体
     * 
     * @param entity
     *            实体对象
     * 
     */
    void delete(Object entity);

    /**
     * 
     * 更新实体
     * 
     * @param entity
     *            实体对象
     * 
     */
    void update(Object entity);

    /**
     * 
     * 保存或更新实体, 实体没有主键时保存，否则更新
     * 
     * @param entity
     *            实体对象
     * 
     */
    void saveOrUpdate(Object entity);

    /**
     * 
     * 批量保存实体
     * 
     * @param entities
     *            实体集合
     */
    void saveAll(Collection entities);

    /**
     * 
     * 批量删除实体
     * 
     * @param entities
     *            实体集合
     * 
     */
    void deleteAll(Collection entities);

    /**
     * 
     * 批量更新实体
     * 
     * @param entities
     *            实体集合
     * 
     */
    void updateAll(Collection entity);

    /**
     * 
     * 批量保存或更新实体, 实体没有主键时保存，否则更新
     * 
     * @param entity
     *            实体集合
     * 
     */
    void saveOrUpdateAll(Collection entities);

    /**
     * 
     * 获取单个实体，根据实体类及实体的主键获取。
     * 
     * @param entityClass
     *            实体类
     * @param id
     *            实体主键
     * @return 实体对象
     */
    @SuppressWarnings("hiding")
     T get(Class entityClass, Serializable id);

    /**
     * 获取单个实体，根据查询语句及参数获取。
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 单个实体，如果查询结果有多个，则返回第一个实体
     */
    @SuppressWarnings("hiding")
     T get(CharSequence queryString, Map params);

    /**
     * 获取单个实体，根据查询语句及参数获取。
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 单个实体，如果查询结果有多个，则返回第一个实体
     */
    @SuppressWarnings("hiding")
     T get(CharSequence queryString, Object... params);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    @SuppressWarnings("hiding")
     List findList(CharSequence queryString, Object... params);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    @SuppressWarnings("hiding")
     List findList(CharSequence queryString, Map params);

    /**
     * 分页查询实体
     * 
     * @param queryString
     *            查询语句
     * @param pageIndex
     *            当前页码，如果pageIndex<1则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * @param params
     *            可选的查询参数
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
     Pagination findPagination(CharSequence queryString, int pageIndex, int pageSize, Object... params);

    /**
     * 分页查询实体
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @param pageIndex
     *            当前页码，如果pageIndex<2则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * 
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
     Pagination findPagination(CharSequence queryString, Map params, int pageIndex, int pageSize);

    /**
     * 分页查询实体，自定义总条数查询语句，适合复杂的hql分页查询
     * 
     * @param queryString
     *            查询语句
     * @param countString
     *            查询记录总条数语句
     * @param pageIndex
     *            当前页码，如果pageIndex<1则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * @param params
     *            可选的查询参数
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
     Pagination findPagination(CharSequence queryString, CharSequence countString, int pageIndex, int pageSize,
            Object... params);

    /**
     * 分页查询实体，自定义总条数查询语句，适合复杂的hql分页查询
     * 
     * @param queryString
     *            查询语句
     * @param countString
     *            查询记录总条数语句
     * @param params
     *            可选的查询参数
     * @param pageIndex
     *            当前页码，如果pageIndex<2则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * 
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
     Pagination findPagination(CharSequence queryString, CharSequence countString, Map params,
            int pageIndex, int pageSize);

    /**
     * 分页查询实体，自定义总条数查询语句，适合复杂的sql分页查询
     * 
     * @param queryString
     *            查询语句
     * @param countString
     *            查询记录总条数语句
     * @param params
     *            可选的查询参数
     * @param pageIndex
     *            当前页码，如果pageIndex<2则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * 
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
    public  Pagination findSqlPagination(final CharSequence queryString, final CharSequence countString,
            final Map params, int pageIndex, int pageSize);

    /**
     * 执行数据库更新操作
     * 
     * @deprecated 用{@link #executeUpdate(String)}替换
     * @param hql
     */
    void execute(String hql);

    /**
     * 执行数据库更新操作
     * 
     * @deprecated 用{@link #executeUpdate(HibernateHandler)}替换
     * @param hql
     */
    void execute(HibernateHandler handler);

    /**
     * 执行数据库更新操作
     * 
     * @deprecated 用{@link #executeSqlUpdate(String)}替换
     * @param sql
     */
    void executeSql(String sql);

    /**
     * 执行数据库查询操作
     * 
     * @param handler
     *            处理器
     * @return
     * @throws Exception
     */
    Object executeQuery(HibernateHandler handler);

    /**
     * 执行数据库更新操作
     * 
     * @param sql
     * @return 更新的记录条数
     */
    int executeSqlUpdate(String sql);

    /**
     * 执行数据库更新操作
     * 
     * @param hql
     * @return 更新的记录条数
     */
    int executeUpdate(String hql);

    /**
     * 执行数据库更新操作
     * 
     * @param handler
     *            处理器
     * @return
     * @throws Exception
     */
    Object executeUpdate(HibernateHandler handler);

    public T getById(Serializable id);

    public T saveEntity(T o);

    public T insert(T o);

    public void save(List list);

    public void insert(List list);

    public void delete(List list);

    public void update(List list);

    public List findByProperty(String name, Object value);

    public List findByProperty(Map conditionMap);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param maxResults
     *            列表最大数
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    public  List findListByMax(CharSequence queryString, int maxResults, Object... params);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param maxResults
     *            列表最大数
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    public  List findListByMax(CharSequence queryString, int maxResults, Map params);
}

BaseDaoImpl.java

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Repository;

import com.xxx.finance.dao.BaseDao;
import com.xxx.finance.utils.HibernateHandler;
import com.xxx.finance.utils.ObjectUtil;
import com.xxx.finance.utils.Pagination;

/**
 * @author 
 */
@Repository
public class BaseDaoImpl implements BaseDao {

    protected Class entityClazz;

    protected SessionFactory sessionFactory;

    @SuppressWarnings("unchecked")
    public BaseDaoImpl() {
        Type type = getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            this.entityClazz = (Class) ((ParameterizedType) type).getActualTypeArguments()[0];
        } else {
            this.entityClazz = null;
        }
    }

    @Resource
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    protected Session getSession() {
        return sessionFactory.getCurrentSession();
    }

    @SuppressWarnings("unchecked")
    public Object save(Object entity) {
        return (T) getSession().save(entity);
    }

    public void delete(Object entity) {

        getSession().delete(entity);
    }

    public void update(Object entity) {

        getSession().update(entity);
    }

    public void saveOrUpdate(Object entity) {

        getSession().saveOrUpdate(entity);
    }

    public void saveAll(Collection entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext();) {
            Object entity = localIterator.next();
            getSession().save(entity);
        }
    }

    public void deleteAll(Collection entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext();) {
            Object entity = localIterator.next();
            getSession().delete(entity);
        }
    }

    public void updateAll(Collection entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext();) {
            Object entity = localIterator.next();
            getSession().update(entity);
        }
    }

    public void saveOrUpdateAll(Collection entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext();) {
            Object entity = localIterator.next();
            getSession().saveOrUpdate(entity);
        }
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  T get(Class entityClass, Serializable id) {

        return (T) getSession().get(entityClass, id);
    }

    @SuppressWarnings({ "unchecked", "rawtypes", "hiding" })
    public  T get(CharSequence queryString, Object... params) {

        Query qry = getSession().createQuery(queryString.toString());
        for (int i = 0; i < params.length; ++i) {
            qry.setParameter(i, params[i]);
        }
        List list = qry.setMaxResults(1).list();
        if (list.isEmpty())
            return null;
        return (T) list.get(0);
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  T get(CharSequence queryString, Map params) {

        Query qry = getSession().createQuery(queryString.toString());
        setParameter(qry, params);
        @SuppressWarnings("rawtypes")
        List list = qry.setMaxResults(1).list();
        if (list.isEmpty())
            return null;
        return (T) list.get(0);
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  List findList(CharSequence queryString, Object... params) {
        Query query = getSession().createQuery(queryString.toString());
        for (int i = 0; i < params.length; ++i) {
            query.setParameter(i, params[i]);
        }
        return query.list();
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  List findList(CharSequence queryString, Map params) {
        Query query = getSession().createQuery(queryString.toString());
        setParameter(query, params);
        return query.list();
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  Pagination findPagination(CharSequence queryString, int pageIndex, int pageSize, Object... params) {
        Query query = getSession().createQuery(queryString.toString());

        if ((pageSize > 0) && (pageIndex > 0)) {
            query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);
            query.setMaxResults(pageSize);
        }

        for (int i = 0; i < params.length; ++i) {
            query.setParameter(i, params[i]);
        }
        @SuppressWarnings("rawtypes")
        List items = query.list();
        long rowsCount = 0L;

        if ((pageSize > 0) && (pageIndex > 0)) {
            String hql = parseSelectCount(queryString.toString());
            rowsCount = ((Long) get(hql, params)).longValue();
        } else {
            rowsCount = items.size();
        }

        @SuppressWarnings("rawtypes")
        Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);
        pagination.setItems(items);
        return pagination;
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  Pagination findPagination(CharSequence queryString, Map params, int pageIndex,
            int pageSize) {
        Query query = getSession().createQuery(queryString.toString());

        if ((pageSize > 0) && (pageIndex > 0)) {
            query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);
            query.setMaxResults(pageSize);
        }

        setParameter(query, params);
        @SuppressWarnings({ "rawtypes" })
        List items = query.list();
        long rowsCount = 0L;

        if ((pageSize > 0) && (pageIndex > 0)) {
            String hql = parseSelectCount(queryString.toString());
            rowsCount = ((Long) get(hql, params)).longValue();
        } else {
            rowsCount = items.size();
        }

        @SuppressWarnings("rawtypes")
        Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);
        pagination.setItems(items);
        return pagination;
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  Pagination findPagination(CharSequence queryString, CharSequence countString, int pageIndex,
            int pageSize, Object... params) {
        Query query = getSession().createQuery(queryString.toString());

        if ((pageSize > 0) && (pageIndex > 0)) {
            query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);
            query.setMaxResults(pageSize);
        }

        for (int i = 0; i < params.length; ++i) {
            query.setParameter(i, params[i]);
        }
        @SuppressWarnings("rawtypes")
        List items = query.list();
        long rowsCount = 0L;

        if ((pageSize > 0) && (pageIndex > 0)) {
            rowsCount = ((Long) get(countString, params)).longValue();
        } else
            rowsCount = items.size();

        @SuppressWarnings("rawtypes")
        Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);
        pagination.setItems(items);
        return pagination;
    }

    @SuppressWarnings({ "unchecked", "hiding" })
    public  Pagination findPagination(CharSequence queryString, CharSequence countString,
            Map params, int pageIndex, int pageSize) {
        Query query = getSession().createQuery(queryString.toString());

        if ((pageSize > 0) && (pageIndex > 0)) {
            query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);
            query.setMaxResults(pageSize);
        }

        setParameter(query, params);
        @SuppressWarnings("rawtypes")
        List items = query.list();
        long rowsCount = 0L;

        if ((pageSize > 0) && (pageIndex > 0)) {
            rowsCount = ((Long) get(countString, params)).longValue();
        } else
            rowsCount = items.size();

        @SuppressWarnings("rawtypes")
        Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);
        pagination.setItems(items);
        return pagination;
    }

    @SuppressWarnings({ "serial", "unchecked", "hiding" })
    public  Pagination findSqlPagination(CharSequence queryString, final CharSequence countString,
            final Map params, int pageIndex, int pageSize) {
        SQLQuery query = getSession().createSQLQuery(queryString.toString());
        query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);

        if ((pageSize > 0) && (pageIndex > 0)) {
            query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);
            query.setMaxResults(pageSize);
        }
        if ((params != null) && (!(params.isEmpty()))) {
            setParameter(query, params);
        }
        @SuppressWarnings("rawtypes")
        List items = query.list();
        BigInteger rowsCount = BigInteger.valueOf(0L);

        if ((pageSize > 0) && (pageIndex > 0)) {
            rowsCount = (BigInteger) executeQuery(new HibernateHandler() {
                public Object doInHibernate(Session session) {
                    SQLQuery query = session.createSQLQuery(countString.toString());
                    if ((params != null) && (!(params.isEmpty()))) {
                        setParameter(query, params);
                    }
                    return query.uniqueResult();
                }
            });
        }

        @SuppressWarnings("rawtypes")
        Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount.intValue());
        pagination.setItems(items);
        return pagination;
    }

    public Object executeQuery(HibernateHandler handler) {
        return handler.doInHibernate(getSession());
    }

    public void execute(String hql) {
        executeUpdate(hql);
    }

    public void execute(HibernateHandler handler) {
        executeUpdate(handler);
    }

    public void executeSql(String sql) {
        executeSqlUpdate(sql);
    }

    public int executeSqlUpdate(String sql) {
        return getSession().createSQLQuery(sql).executeUpdate();
    }

    public int executeUpdate(String hql) {
        return getSession().createQuery(hql).executeUpdate();
    }

    public Object executeUpdate(HibernateHandler handler) {
        return handler.doInHibernate(getSession());
    }

    protected Query setParameter(Query query, Map parameterMap) {
        for (@SuppressWarnings("rawtypes")
        Iterator iterator = parameterMap.keySet().iterator(); iterator.hasNext();) {
            String key = (String) iterator.next();
            query.setParameter(key, parameterMap.get(key));
        }
        return query;
    }

    protected boolean followWithWord(String s, String sub, int pos) {
        int i = 0;
        for (; (pos < s.length()) && (i < sub.length()); ++i) {
            if (s.charAt(pos) != sub.charAt(i))
                return false;
            ++pos;
        }

        if (i < sub.length()) {
            return false;
        }

        if (pos >= s.length()) {
            return true;
        }
        return (!(isAlpha(s.charAt(pos))));
    }

    protected String parseSelectCount(String queryString) {
        String hql = queryString.toLowerCase();
        int noBlankStart = 0;
        for (int len = hql.length(); noBlankStart < len; ++noBlankStart) {
            if (hql.charAt(noBlankStart) > ' ') {
                break;
            }
        }

        int pair = 0;

        if (!(followWithWord(hql, "select", noBlankStart))) {
            pair = 1;
        }
        int fromPos = -1;
        for (int i = noBlankStart; i < hql.length();) {
            if (followWithWord(hql, "select", i)) {
                ++pair;
                i += "select".length();
            } else if (followWithWord(hql, "from", i)) {
                --pair;
                if (pair == 0) {
                    fromPos = i;
                    break;
                }
                i += "from".length();
            } else {
                ++i;
            }
        }
        if (fromPos == -1) {
            throw new IllegalArgumentException("parse count sql error, check your sql/hql");
        }

        String countHql = "select count(*) " + queryString.substring(fromPos);
        return countHql;
    }

    protected boolean isAlpha(char c) {
        return ((c == '_') || (('0' <= c) && (c <= '9')) || (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')));
    }

    public void delete(Serializable id) {
        T entity = getById(id);
        delete(entity);
    }

    public void delete(List entitys) {
        for (T entity : entitys) {
            delete(entity);
        }
    }

    public T getById(Serializable id) {
        if (id == null)
            return null;

        return (T) get(entityClazz, id);
    }

    @Override
    public T saveEntity(T o) {
        saveOrUpdate(o);
        return o;
    }

    @Override
    public void save(List list) {
        saveOrUpdateAll(list);
    }

    @Override
    public T insert(T entity) {
        save(entity);
        return entity;
    }

    @Override
    public void insert(List entitys) {
        for (T entity : entitys) {
            save(entity);
        }
    }

    @Override
    public void update(List entitys) {
        for (T entity : entitys) {
            update(entity);
        }
    }

    @Override
    public List findByProperty(String name, Object value) {
        String hql = "from  " + entityClazz.getSimpleName() + " where " + name + "=? ";
        return findList(hql, value);
    }

    @Override
    public List findByProperty(Map conditionMap) {
        StringBuilder hql = new StringBuilder();
        hql.append("from  " + entityClazz.getSimpleName());
        if (!conditionMap.isEmpty()) {
            Iterator it = conditionMap.keySet().iterator();
            String key = it.next();
            hql.append(" where  " + key + "=:" + key);
            while (it.hasNext()) {
                key = it.next();
                hql.append(" and  " + key + "=:" + key);
            }
        }
        return findList(hql.toString(), conditionMap);
    }

    @Override
    public  List findListByMax(final CharSequence queryString, final int maxResults, final Object... params) {
        @SuppressWarnings({ "unchecked", "serial" })
        List list = (List) executeQuery(new HibernateHandler() {
            @Override
            public List doInHibernate(Session paramSession) {
                try {
                    Query query = paramSession.createQuery(queryString.toString());
                    for (int i = 0; i < params.length; ++i) {
                        query.setParameter(i, params[i]);
                    }
                    return query.setMaxResults(maxResults).list();
                } catch (RuntimeException re) {
                    throw re;
                }
            }
        });
        return list;
    }

    @Override
    public  List findListByMax(final CharSequence queryString, final int maxResults,
            final Map params) {
        @SuppressWarnings({ "unchecked", "serial" })
        List list = (List) executeQuery(new HibernateHandler() {
            @Override
            public List doInHibernate(Session paramSession) {
                try {
                    Query query = paramSession.createQuery(queryString.toString());
                    for (Iterator iterator = params.keySet().iterator(); iterator.hasNext();) {
                        String key = iterator.next();
                        query.setParameter(key, params.get(key));
                    }
                    return query.setMaxResults(maxResults).list();
                } catch (RuntimeException re) {
                    throw re;
                }
            }

        });
        return list;
    }

    /**
     * HQL/SQL之数据操作命令(DML)拼接辅助类
     * 
     * @author PanJun
     * @deprecated by fu.zhanghua
     * 
     */
    public class DmlHelper {

        private ThreadLocal cal = new ThreadLocal() {
            @Override
            protected Calendar initialValue() {
                return Calendar.getInstance();
            }
        };

        /** HQL/SQL参数 */
        public final List