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操作 结束 --------------------------------------------
}