HibernateTemplateDAO笔记

package com.mnt.database.dao;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.LockOptions;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mnt.bean.QueryResultVo;
import com.mnt.common.constants.PublicConstant;
import com.mnt.common.result.ResultCode;
import com.mnt.common.util.BeanUtilTools;
import com.mnt.database.util.DAOUtil;
import com.mnt.database.util.QueryCondition;
import com.mnt.service.exception.CoreServiceException;

/**
 * Hibernate模板类
 * 
 * @author zy
 * @version 1.0
 * 
 *          变更履历：
 *          v1.0 2016-1-8 zy 初版
 */
@SuppressWarnings("unchecked")
public abstract class HibernateTemplateDAO {

    private static final Logger LOGGER = LoggerFactory.getLogger(HibernateTemplateDAO.class);

    public abstract Session getCurrentSession();

    /**
     * 保存操作
     * 
     * @param Object
     *            entity
     * @return Serializable 主键
     */
    public Serializable save(Object entity) {
        return this.getCurrentSession().save(entity);
    }

    /**
     * 更新操作
     * 
     * @param Object
     *            entity
     */
    public void update(Object entity) {
        this.getCurrentSession().update(entity);
    }

    /**
     * 保存或更新
     * 
     * @param Object
     *            entity
     */
    public void saveOrUpdate(Object entity) {
        this.getCurrentSession().saveOrUpdate(entity);
    }

    /**
     * 刪除操作
     * 
     * @param Object
     *            entity
     */
    public void delete(Object entity) {
        this.getCurrentSession().delete(entity);
    }

    /**
     * 单表主键查询
     * 
     * @param Class
     *            ORM对象
     * @param id
     *            主键
     * @return Object ORM对象
     */
    public <T> T get(Class<T> clazz, Serializable id) {
        return (T) this.getCurrentSession().get(clazz, id);
    }

    /**
     * 单表主键查询<br>
     * 1、增加数据锁<br>
     * 2、事务结束后，锁自动释放
     * 
     * @param Class
     *            ORM对象
     * @param id
     *            主键
     * @param lockOptions
     *            锁
     * @return Object ORM对象
     */
    public <T> T get(Class<T> clazz, Serializable id, LockOptions lockOptions) {
        return (T) this.getCurrentSession().get(clazz, id, lockOptions);
    }

    /**
     * 单表主键查询 <br>
     * 1、返回指定实体类(返回的实体类属性<=hibernate实体类) <br>
     * 2、实体类与ORM对象属性名一致
     * 
     * @author zy
     * @param clazz
     *            ORM对象
     * @param id
     *            主键
     * @param transformerBean
     *            返回的实体类型
     * @return 实体类
     */
    public <T, A> A getTransformerBean(Serializable id, Class<T> clazz, Class<A> transformerBean) {
        Object obj = this.getCurrentSession().get(clazz, id);
        if (obj != null) {
            return BeanUtilTools.transformerProperties(transformerBean, obj);
        }
        return null;
    }

    /**
     * 单表主键查询 <br>
     * 1、返回指定实体类(返回的实体类属性<=hibernate实体类)<br>
     * 2、实体类与ORM对象属性名一致<br>
     * 3、增加数据锁<br>
     * 4、事务结束后，锁自动释放
     * 
     * @author zy
     * @param clazz
     *            hibernate查询类
     * @param id
     *            主键
     * @param transformerBean
     *            指定的实体类
     * @param lockOptions
     *            锁
     * @return 实体类
     */
    public <T, A> A getTransformerBean(Serializable id, Class<T> clazz, Class<A> transformerBean,
            LockOptions lockOptions) {
        Object obj = this.getCurrentSession().get(clazz, id, lockOptions);
        if (obj != null) {
            return BeanUtilTools.transformerProperties(transformerBean, obj);
        }
        return null;
    }

    /**
     * 单表综合检索(分页查询)
     * 
     * @param condition
     *            检索条件
     * @param voClass
     *            检索返回类
     * @param tableName
     *            表名
     * @return List<T>
     * @throws CoreServiceException
     */
    public <T> List<T> query(Object condition, Class<T> voClass, String tableName) {
        // 初始化查询集合类
        List<T> vos = null;
        // TO-bean的类名=别名
        String aliasName = voClass.getSimpleName();
        // 初始化变量-检索条件类
        QueryCondition queryCondition;
        // 当前次数
        Integer current = 1;
        // 当前总数
        Integer currentCount = PublicConstant.MAX_RECORD;
        // 记录总数
        Integer totalCount = 0;
        // 检索的字段
        String queryField;
        // HQL检索语句
        String queryHQL;
        // HQL检索统计语句
        String countHQL;
        if (condition == null) {
            condition = new QueryResultVo();
        }
        try {
            // 通过注解与类获取检索HQL语句与检索参数集合(检索条件不支持复合类)
            queryCondition = DAOUtil.getQueryConditionHQL(condition, aliasName);
            // 获取查询的字段列表
            queryField = DAOUtil.getHQLFields(voClass, voClass.getSimpleName());
            // 组合完整HQL检索语句
            if (StringUtils.isEmpty(queryCondition.getOrderString())) {
                queryHQL = "SELECT" + queryField + " FROM " + tableName + " AS " + aliasName + " "
                        + queryCondition.getQueryString() + " ORDER BY " + aliasName + ".updateTime DESC";
            } else {
                queryHQL = "SELECT" + queryField + " FROM " + tableName + " AS " + aliasName + " "
                        + queryCondition.getQueryString() + queryCondition.getOrderString();
            }
            // 组合完整的记录总数统计HQL
            countHQL = "SELECT COUNT(" + aliasName + ".flag) FROM " + tableName + " AS " + aliasName + " "
                    + queryCondition.getQueryString();
            // 检索记录总数
            totalCount = this.HQLCount(countHQL, queryCondition.getQueryParams());
            // 记录总数复制
            BeanUtils.setProperty(condition, "totalCount", totalCount);
            // 获取当前记录次数
            String currentStr = BeanUtils.getProperty(condition, "current");
            if (!StringUtils.isEmpty(currentStr)) {
                current = Integer.valueOf(currentStr);
            }
            BeanUtils.setProperty(condition, "current", current);
            BeanUtils.setProperty(condition, "currentCount", currentCount);
            // 检索结果集合
            vos = this.HQLQueryAlias(queryHQL, current, currentCount, queryCondition.getQueryParams(),
                    voClass);
        } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException
                 | NoSuchMethodException e) {
            LOGGER.error("HQL单表通用查询异常", e);
            throw new CoreServiceException(ResultCode.ERROR_90005, e);
        }
        return vos;
    }

    /**
     * 单表综合检索
     * 
     * @param condition
     *            检索条件
     * @param voClass
     *            检索返回类
     * @param tableName
     *            表名
     * @return List<T>
     * @throws CoreServiceException
     */
    public <T> List<T> queryAll(Object condition, Class<T> voClass, String tableName) {
        // 初始化查询集合类
        List<T> vos = null;
        // TO-bean的类名=别名
        String aliasName = voClass.getSimpleName();
        // 初始化变量-检索条件类
        QueryCondition queryCondition;
        // 检索的字段
        String queryField;
        // HQL检索语句
        String queryHQL;
        try {
            // 通过注解与类获取检索HQL语句与检索参数集合(检索条件不支持复合类)
            queryCondition = DAOUtil.getQueryConditionHQL(condition, aliasName);
            // 获取查询的字段列表
            queryField = DAOUtil.getHQLFields(voClass, voClass.getSimpleName());
            // 组合完整HQL检索语句
            if (StringUtils.isEmpty(queryCondition.getOrderString())) {
                queryHQL = "SELECT" + queryField + " FROM " + tableName + " AS " + aliasName + " "
                        + queryCondition.getQueryString() + " ORDER BY " + aliasName + ".updateTime DESC";
            } else {
                queryHQL = "SELECT" + queryField + " FROM " + tableName + " AS " + aliasName + " "
                        + queryCondition.getQueryString() + queryCondition.getOrderString();
            }
            // 检索结果集合
            vos = this.HQLQueryAlias(queryHQL, queryCondition.getQueryParams(), voClass);
        } catch (Exception e) {
            LOGGER.error("HQL单表通用查询异常", e);
            throw new CoreServiceException(ResultCode.ERROR_90005, e);
        }
        return vos;
    }

    // ****************************************** HQL操作 开始 ********************************************

    /**
     * HQL查询
     * 
     * @param hql
     * @return List<T>
     */
    public <T> List<T> HQLQuery(String hql) {
        return this.getHQLQuery(hql, null, null, false, null, null).list();
    }

    /**
     * HQL条件查询
     * 
     * @param hql
     *            查询语句
     * @param entity
     *            Map键值对形式的参数-检索条件
     * @return List<T>
     */
    public <T> List<T> HQLQuery(String hql, Map<String, Object> entity) {
        return this.getHQLQuery(hql, null, null, false, entity, null).list();
    }

    /**
     * HQL条件查询【第一条信息】
     * 
     * 1、返回首记录
     * 
     * @param hql
     *            语句
     * @param entity
     *            Map键值对形式的参数-检索条件
     * @return T
     */
    public <T> T HQLQueryFirst(String hql, Map<String, Object> entity) {
        List<T> list = this.HQLQuery(hql, entity);
        return CollectionUtils.isEmpty(list) ? null : list.get(0);
    }

    /**
     * HQL条件查询【分页】
     * 
     * @param hql
     *            语句
     * @param page
     *            当前页
     * @param rows
     *            返回行数
     * @param entity
     *            Map键值对形式的参数
     * @return List<Pojo>
     */
    public <T> List<T> HQLQuery(String hql, Integer page, Integer rows, Map<String, Object> entity) {
        return this.getHQLQuery(hql, page, rows, true, entity, null).list();
    }

    /**
     * HQL映射查询
     * 
     * 1、返回别名映射类
     * 
     * @param hql
     *            查询
     * @param aliasToClazz
     *            别名TO类
     * @return List<T>
     */
    public <T> List<T> HQLQueryAlias(String hql, Class<T> aliasToClazz) {
        return this.getHQLQuery(hql, null, null, false, null, null)
                .setResultTransformer(Transformers.aliasToBean(aliasToClazz)).list();
    }

    /**
     * HQL条件映射查询
     * 
     * 1、返回别名映射类
     * 
     * @param hql
     *            查询
     * @param entity
     *            Map键值对形式的参数
     * @param aliasToClazz
     *            别名TO类
     * @return List<T>
     */
    public <T> List<T> HQLQueryAlias(String hql, Map<String, Object> entity, Class<T> aliasToClazz) {
        return this.getHQLQuery(hql, null, null, false, entity, null)
                .setResultTransformer(Transformers.aliasToBean(aliasToClazz)).list();
    }

    /**
     * HQL条件映射查询【第一条信息】
     * 
     * 1、返回别名映射类
     * 
     * @param hql
     *            查询
     * @param entity
     *            Map键值对形式的参数
     * @param aliasToClazz
     *            别名TO类
     * @return List<T>
     */
    public <T> T HQLQueryAliasFirst(String hql, Map<String, Object> entity, Class<T> aliasToClazz) {
        List<T> list = this.HQLQueryAlias(hql, entity, aliasToClazz);
        return CollectionUtils.isEmpty(list) ? null : list.get(0);
    }

    /**
     * HQL条件映射查询【分页】
     * 
     * 1、返回别名映射类
     * 2、支持分页查询
     * 
     * @param hql
     * @param page
     *            当前页
     * @param rows
     *            返回行数
     * @param entity
     *            Map键值对形式的参数
     * @param aliasToClazz
     *            别名TO类
     * @return List<Pojo>
     */
    public <T> List<T> HQLQueryAlias(String hql, Integer page, Integer rows, Map<String, Object> entity,
            Class<T> aliasToClazz) {
        return this.getHQLQuery(hql, page, rows, true, entity, null)
                .setResultTransformer(Transformers.aliasToBean(aliasToClazz)).list();
    }

    /**
     * HQL-count函数统计语句
     * 
     * @param hql
     * @return Integer 统计数
     */
    public Integer HQLCount(String hql) {
        Long count = (Long) this.getCurrentSession().createQuery(hql).uniqueResult();
        return count == null ? 0 : count.intValue();
    }

    /**
     * HQL-count函数统计条件语句
     * 
     * @param hql
     * @param entity
     *            Map键值对形式的参数
     * @return Integer 记录数
     */
    public Integer HQLCount(String hql, Map<String, Object> entity) {
        Long count = (Long) this.getHQLQuery(hql, null, null, false, entity, null).uniqueResult();
        return count == null ? 0 : count.intValue();
    }

    /**
     * HQL执行语句
     * 
     * @param hql
     * @return Integer 操作记录数
     */
    public Integer executeHQL(String hql) {
        return this.getCurrentSession().createQuery(hql).executeUpdate();
    }

    /**
     * HQL执行条件语句
     * 
     * @param hql
     * @param entity
     *            Map键值对形式的参数
     * @return Integer
     */
    public Integer executeHQL(String hql, Map<String, Object> entity) {
        return this.getHQLQuery(hql, null, null, false, entity, null).executeUpdate();
    }

    /**
     * HQL获取Query
     * 
     * @param hql
     *            查询语句
     * @param page
     *            当前页数
     * @param rows
     *            当前返回记录数
     * @param isPage
     *            是否分页
     * @param entity
     *            条件
     * @param lockOptions
     *            锁
     * @return
     */
    public Query getHQLQuery(String hql, Integer page, Integer rows, Boolean isPage, Map<String, Object> entity,
            LockOptions lockOptions) {
        Query q = this.getCurrentSession().createQuery(hql);
        if (entity != null && entity.size() > 0) {
            Set<String> keySet = entity.keySet();
            for (String string : keySet) {
                Object obj = entity.get(string);
                // 这里考虑传入的参数是什么类型，不同类型使用的方法不同
                if (obj instanceof Collection<?>) {
                    q.setParameterList(string, (Collection<?>) obj);
                } else if (obj instanceof Object[]) {
                    q.setParameterList(string, (Object[]) obj);
                } else {
                    q.setParameter(string, obj);
                }
            }
        }
        if (isPage) {
            if (page == null || page < 1) {
                page = 1;
            }
            if (rows == null || rows < 1) {
                rows = 10;
            }
            return q.setFirstResult((page - 1) * rows).setMaxResults(rows);
        }
        if (lockOptions != null) {
            q.setLockOptions(lockOptions);
        }
        return q;
    }

    // ------------------------------------------ HQL操作 结束 --------------------------------------------

    // ****************************************** SQL操作 开始 ********************************************

    /**
     * 分页条件检索
     * 
     * @author zcq
     * @param condition
     * @param querySQL
     * @param countSQL
     * @param paramsMap
     * @param clazz
     * @return
     */
    public <T> List<T> query(Object condition, String querySQL, String countSQL, Map<String, Object> paramsMap,
            Class<T> clazz) {
        // 当前次数
        Integer current = 1;
        // 当前总数
        Integer currentCount = PublicConstant.MAX_RECORD;
        // 记录总数
        Integer totalCount = 0;
        // 检索记录总数
        totalCount = this.SQLCount(countSQL, paramsMap);
        try {
            // 记录总数复制
            BeanUtils.setProperty(condition, "totalCount", totalCount);
            // 获取当前记录次数
            String currentStr = BeanUtils.getProperty(condition, "current");
            if (!StringUtils.isEmpty(currentStr)) {
                current = Integer.valueOf(currentStr);
            }
            BeanUtils.setProperty(condition, "current", current);
            BeanUtils.setProperty(condition, "currentCount", currentCount);
        } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException
                 | NoSuchMethodException e) {
            throw new CoreServiceException(ResultCode.ERROR_90005);
        }

        return this.SQLQueryAlias(querySQL, current, currentCount, paramsMap, clazz);
    }

    /**
     * SQL查询
     * 
     * @param sql
     * @return List<T>
     */
    public <T> List<T> SQLQuery(String sql) {
        return this.getSQLQuery(sql, null, null, false, null, null, null).list();
    }

    /**
     * SQL条件查询
     * 
     * @param sql
     * @param entity
     *            Map键值对形式的参数
     * @return List<T>
     */
    public <T> List<T> SQLQuery(String sql, Map<String, Object> entity) {
        return this.getSQLQuery(sql, null, null, false, entity, null, null).list();
    }

    /**
     * SQL条件查询【第一条信息】
     * 
     * @param sql
     * @param entity
     *            Map键值对形式的参数
     * @return <T>
     */
    public <T> T SQLQueryFirst(String sql, Map<String, Object> entity) {
        List<T> list = this.SQLQuery(sql, entity);
        return CollectionUtils.isEmpty(list) ? null : list.get(0);
    }

    /**
     * SQL条件查询【分页】
     * 
     * @param sql
     * @param page
     *            当前页
     * @param rows
     *            返回行数
     * @param entity
     *            Map键值对形式的参数
     * @return List<Pojo>
     */
    public <T> List<T> SQLQuery(String sql, Integer page, Integer rows, Map<String, Object> entity) {
        return this.getSQLQuery(sql, page, rows, true, entity, null, null).list();
    }

    /**
     * SQL映射查询(H)
     * 
     * @param sql
     * @param clazz
     *            数据实体类
     * @return List<T>
     */
    public <T> List<T> SQLQuery(String sql, Class<T> clazz) {
        return this.getSQLQuery(sql, null, null, false, null, null, clazz).list();
    }

    /**
     * SQL条件映射查询(H)
     * 
     * @param sql
     * @param entity
     *            Map键值对形式的参数
     * @param clazz
     *            数据实体类
     * @return List<T>
     */
    public <T> List<T> SQLQuery(String sql, Map<String, Object> entity, Class<T> clazz) {
        return this.getSQLQuery(sql, null, null, false, entity, null, clazz).list();
    }

    /**
     * SQL条件映射查询【第一条信息】(H)
     * 
     * @param sql
     * @param entity
     *            Map键值对形式的参数
     * @param clazz
     *            数据实体类
     * @return List<T>
     */
    public <T> T SQLQueryFirst(String sql, Map<String, Object> entity, Class<T> clazz) {
        List<T> list = this.SQLQuery(sql, entity, clazz);
        return CollectionUtils.isEmpty(list) ? null : list.get(0);
    }

    /**
     * SQL条件映射查询【分页】(H)
     * 
     * @param sql
     * @param page
     *            当前页
     * @param rows
     *            返回行数
     * @param entity
     *            Map键值对形式的参数
     * @param clazz
     *            数据实体类
     * @return List<Pojo>
     */
    public <T> List<T> SQLQuery(String sql, Integer page, Integer rows, Map<String, Object> entity,
            Class<T> clazz) {
        return this.getSQLQuery(sql, page, rows, true, entity, null, clazz).list();
    }

    /**
     * SQL映射查询(S)
     * 
     * @param sql
     *            查询语句
     * @param aliasToClazz
     *            返回非受管实体(Returning non-managed entities)
     * @return List<Pojo>
     */
    public <T> List<T> SQLQueryAlias(String sql, Class<T> aliasToClazz) {
        return this.getSQLQuery(sql, null, null, false, null, null, null)
                .setResultTransformer(Transformers.aliasToBean(aliasToClazz)).list();
    }

    /**
     * SQL条件映射查询(S)
     * 
     * @param sql
     *            查询语句
     * @param entity
     *            Map键值对形式的参数
     * @param aliasToClazz
     *            返回非受管实体(Returning non-managed entities)
     * @return List<Pojo>
     */
    public <T> List<T> SQLQueryAlias(String sql, Map<String, Object> entity, Class<T> aliasToClazz) {
        return this.getSQLQuery(sql, null, null, false, entity, null, null)
                .setResultTransformer(Transformers.aliasToBean(aliasToClazz)).list();
    }

    /**
     * SQL条件映射查询【第一条信息】(S)
     * 
     * 1、返回别名映射类
     * 
     * @param sql
     *            查询
     * @param entity
     *            Map键值对形式的参数
     * @param aliasToClazz
     *            返回非受管实体(Returning non-managed entities)
     * @return List<T>
     */
    public <T> T SQLQueryAliasFirst(String sql, Map<String, Object> entity, Class<T> aliasToClazz) {
        List<T> list = this.SQLQueryAlias(sql, entity, aliasToClazz);
        return CollectionUtils.isEmpty(list) ? null : list.get(0);
    }

    /**
     * SQL条件映射查询【分页】(S)
     * 
     * @param sql
     *            查询语句
     * @param page
     *            当前页
     * @param rows
     *            返回行数
     * @param entity
     *            Map键值对形式的参数
     * @param aliasToClazz
     *            返回非受管实体(Returning non-managed entities)
     * @return List<Pojo>
     */
    public <T> List<T> SQLQueryAlias(String sql, Integer page, Integer rows, Map<String, Object> entity,
            Class<T> aliasToClazz) {
        return this.getSQLQuery(sql, page, rows, true, entity, null, null)
                .setResultTransformer(Transformers.aliasToBean(aliasToClazz)).list();
    }

    /**
     * SQL执行语句
     * 
     * @param sql
     * @return Integer 操作记录数
     */
    public Integer executeSQL(String sql) {
        return this.getCurrentSession().createSQLQuery(sql).executeUpdate();
    }

    /**
     * SQL执行条件语句
     * 
     * @param sql
     * @return Integer 操作记录数
     */
    public Integer executeSQL(String sql, Map<String, Object> entity) {
        return this.getSQLQuery(sql, null, null, false, entity, null, null).executeUpdate();
    }

    /**
     * SQL-count函数统计语句
     * 
     * @param sql
     * @return Integer 记录数
     */
    public Integer SQLCount(String sql) {
        BigInteger count = (BigInteger) this.getCurrentSession().createSQLQuery(sql).uniqueResult();
        return count.intValue();
    }

    /**
     * SQL-count函数统计条件语句
     * 
     * @param sql
     * @param entity
     *            Map键值对形式的参数
     * @return Integer 记录数
     */
    public Integer SQLCount(String sql, Map<String, Object> entity) {
        BigInteger count = (BigInteger) this.getSQLQuery(sql, null, null, false, entity, null, null)
                .uniqueResult();
        return count.intValue();
    }

    /**
     * 通用查询
     * 
     * @param sql
     *            查询语句
     * @param page
     *            当前页数
     * @param rows
     *            当前返回记录数
     * @param isPage
     *            是否分页
     * @param entity
     *            条件
     * @param lockOptions
     *            锁
     * @param clazz
     *            承载数据实体类
     * @return
     */
    public <T> Query getSQLQuery(String sql, Integer page, Integer rows, Boolean isPage, Map<String, Object> entity,
            LockOptions lockOptions, Class<T> clazz) {
        Query q = null;
        if (clazz != null) {
            q = this.getCurrentSession().createSQLQuery(sql).addEntity(clazz);
        } else {
            q = this.getCurrentSession().createSQLQuery(sql);
        }
        if (entity != null && entity.size() > 0) {
            q.setProperties(entity);
        }
        if (isPage) {
            if (page == null || page < 1) {
                page = 1;
            }
            if (rows == null || rows < 1) {
                rows = 10;
            }
            return q.setFirstResult((page - 1) * rows).setMaxResults(rows);
        }
        if (lockOptions != null) {
            q.setLockOptions(lockOptions);
        }
        return q;
    }
    // ------------------------------------------ SQL操作 结束 --------------------------------------------
}