package com.dao;
import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.StatelessSession;
import org.hibernate.Transaction;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.ProjectionList;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate4.HibernateCallback;
import org.springframework.orm.hibernate4.HibernateTemplate;
import org.springframework.util.StringUtils;
import com.pojo.CutPage;
/**
*
* 所有方法均可能抛出运行时异常DataAccessException，请谨慎处理
*
*/
public class BaseDao {
private HibernateTemplate hibernateTemplate;
private final static Logger LOGGER = Logger.getLogger(BaseDao.class);
public Session getSession() {
return getHibernateTemplate().getSessionFactory().openSession();
}
/**
*
*
* @param <T>
* @param t
* @param firstResult
* @param maxResult
* @param orderList
* @return
*/
public <T> CutPage findByPageUseLike(final T t, final int firstResult, final int maxResult, final List<Order> orderList, String tableAndColumn) {
final Example example = Example.create(t).excludeZeroes().enableLike(MatchMode.ANYWHERE);
return getHibernateTemplate().execute(new CallbackFindByPageUseLike(example, firstResult, maxResult, t.getClass(), orderList, tableAndColumn));
}
/**
* 离线查询，一般用于复杂查询
*
* @param detachedCriteria
* @return
*/
public List<?> findByPage(final DetachedCriteria detachedCriteria) {
return getHibernateTemplate().findByCriteria(detachedCriteria);
}
/**
* 离线分页查询，一般用于复杂分页查询
*
* @param <T>
* @param detachedCriteria
* @param firstResult
* @param maxResult
* @return
*/
public <T> CutPage findByPage(final DetachedCriteria detachedCriteria, final int firstResult, final int maxResult) {
return getHibernateTemplate().executeWithNativeSession(new CallbackFindByPageUseCriteria(detachedCriteria, firstResult, maxResult));
}
public <T> CutPage findByPageX(final DetachedCriteria detachedCriteria, final int firstResult, final int maxResult, ProjectionList p, String distinctColumn,
String orderColumn) {
return getHibernateTemplate()
.executeWithNativeSession(new CallbackFindByPageUseCriteriaX(detachedCriteria, firstResult, maxResult, p, distinctColumn, orderColumn));
}
public <T> void saveOrUpdate(T t) {
if (t == null) {
LOGGER.error("no entity!");
}
else {
LOGGER.info("save or update " + t.getClass().getName());
getHibernateTemplate().saveOrUpdate(t);
}
}
public <T> void batchInsert(List<T> ts) {
StatelessSession session = getHibernateTemplate().getSessionFactory().openStatelessSession();
Transaction tx = session.beginTransaction();
for (T t : ts) {
if (t == null) {
LOGGER.error("batchInsert:no entity");
}
else {
LOGGER.info("batchInsert:save or update" + t.getClass().getName());
session.insert(t);
}
}
tx.commit();
session.close();
}
/**
* 由传入对象构造Example对象的模糊分页查询
*
* @param <T>
* @param t
* @param firstResult
* @param maxResult
* @return
*/
public <T> CutPage findByPageUseLike(final T t, final int firstResult, final int maxResult) {
final Example example = Example.create(t).excludeZeroes().enableLike(MatchMode.ANYWHERE);
return getHibernateTemplate().execute(new CallbackFindByPageUseLike(example, firstResult, maxResult, t.getClass(), null, null));
}
/**
*
*
* @param <T>
* @param t
* @param firstResult
* @param maxResult
* @param orderList
* @return
*/
public <T> CutPage findByPageUseLike(final T t, final int firstResult, final int maxResult, final List<Order> orderList) {
final Example example = Example.create(t).excludeZeroes().enableLike(MatchMode.ANYWHERE);
return getHibernateTemplate().execute(new CallbackFindByPageUseLike(example, firstResult, maxResult, t.getClass(), orderList, null));
}
public <T> void toUpdate(T t) {
if (t == null) {
LOGGER.error("no entity!");
}
else {
LOGGER.info("save or update " + t.getClass().getName());
getHibernateTemplate().update(t);
}
}
public <T> void delete(T t) {
getHibernateTemplate().delete(t);
}
public <T> void delete(Class<T> entityClass, Integer id) {
LOGGER.info("delete " + entityClass.getClass().getName());
getHibernateTemplate().delete(get(entityClass, id));
}
public <T> T get(Class<T> entityClass, Integer id) {
return getHibernateTemplate().get(entityClass, id);
}
/**
* 根据id查询
*
* @param hql
* @param entityClass
* @return
*/
public <T> T get(Class<T> entityClass, Serializable id) {
return getHibernateTemplate().get(entityClass, id);
}
/**
* 根据传入对象查询
*
* @param <T>
* @param t
* @return
*/
public <T> List<T> find(T t) {
return getHibernateTemplate().findByExample(t);
}
public <T> T findOne(T t) {
List<T> list = null;
try {
list = getHibernateTemplate().findByExample(t, 0, 1);
}
catch (DataAccessException e) {
LOGGER.error(e, e);
}
if (list == null || list.size() == 0) {
return null;
}
return list.get(0);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> List<T> findUseLike(final T t) {
final Example example = Example.create(t).excludeZeroes().enableLike(MatchMode.ANYWHERE);
return getHibernateTemplate().execute((HibernateCallback<List<T>>) new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException {
return session.createCriteria(t.getClass()).add(example).list();
}
});
}
public <T> List<T> findAll(Class<T> entityClass) {
return getHibernateTemplate().loadAll(entityClass);
}
public <T> List<T> findAll(String hql, Class<T> entityClass) {
return findAll(hql, entityClass, new Object[] {});
}
public <T> List<T> findAll(String hql, Class<T> entityClass, Object param) {
return findAll(hql, entityClass, new Object[] { param });
}
public <T> List<T> findAll(String hql, Class<T> entityClass, Object[] params) {
return getHibernateTemplate().execute(new CallbackByQuery<T>(hql, params));
}
public List<Object[]> findAllBySql(String sql) {
return findAllBySql(sql, new Object[] {});
}
public List<Object[]> findAllBySql(String sql, Object param) {
return findAllBySql(sql, new Object[] { param });
}
public List<Object[]> findAllBySql(String sql, Object[] params) {
return getHibernateTemplate().execute(new CallbackBySqlQuery(sql, params));
}
public List<Object> findAllBySql3(String sql, Object[] params) {
return getHibernateTemplate().execute(new CallbackBySqlQuery3(sql, params));
}
public List<Object[]> findAllBySql2(String sql, Map<String, Object> params) {
return getHibernateTemplate().execute(new CallbackBySqlQuery2(sql, params));
}
public <T> List<T> findByPage(String hql, Class<T> entityClass, int firstResult, int maxResult) {
return findByPage(hql, entityClass, new Object[] {}, firstResult, maxResult);
}
public <T> List<T> findByPage(String hql, Class<T> entityClass, Object param, int firstResult, int maxResult) {
return findByPage(hql, entityClass, new Object[] { param }, firstResult, maxResult);
}
public <T> List<T> findByPage(String hql, Class<T> entityClass, Object[] params, int firstResult, int maxResult) {
return getHibernateTemplate().execute(new CallbackByQuery<T>(hql, params, firstResult, maxResult));
}
public int updateBySql(String sql, Object... params) {
return getHibernateTemplate().execute(new CallbackBySqlDML(sql, params));
}
public List<Map<String, Object>> findAllBySql(String sql, Object[] params, List<String> titles) {
List<Object[]> result = findAllBySql(sql, params);
List<Map<String, Object>> list = new LinkedList<Map<String, Object>>();
for (Object[] objs : result) {
Map<String, Object> map = new HashMap<String, Object>();
list.add(map);
for (int i = 0; i < titles.size(); i++) {
map.put(titles.get(i), objs.length > i ? objs[i] : null);
}
}
return list;
}
public List<Map<String, Object>> findAllBySqlToMap(String sql) {
return findAllBySqlToMap(sql, new Object[] {});
}
public List<Map<String, Object>> findAllBySqlToMap(String sql, Object param) {
return findAllBySqlToMap(sql, new Object[] { param });
}
public List<Map<String, Object>> findAllBySqlToMap(String sql, Object[] params) {
return getHibernateTemplate().execute(new CallbackBySqlQueryMap(sql, params));
}
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
private class CallbackByQuery<T> implements HibernateCallback<List<T>> {
private String hql;
private Object[] params;
private boolean isByPage = false;
private int firstResult;
private int maxResult;
public CallbackByQuery(String hql, Object[] params) {
super();
this.hql = hql;
this.params = params;
}
public CallbackByQuery(String hql, Object[] params, int firstResult, int maxResult) {
super();
this.hql = hql;
this.params = params;
this.isByPage = true;
this.firstResult = firstResult;
this.maxResult = maxResult;
}
@Override
public List<T> doInHibernate(Session session) throws HibernateException {
Query query = session.createQuery(hql);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
if (isByPage) {
query.setFirstResult(firstResult);
query.setMaxResults(maxResult);
}
@SuppressWarnings("unchecked")
List<T> list = query.list();
return list;
}
}
private class CallbackBySqlQuery implements HibernateCallback<List<Object[]>> {
private String sql;
private Object[] params;
public CallbackBySqlQuery(String sql, Object[] params) {
super();
this.sql = sql;
this.params = params;
}
@Override
public List<Object[]> doInHibernate(Session session) throws HibernateException {
LOGGER.info(sql);
SQLQuery query = session.createSQLQuery(sql);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
@SuppressWarnings("unchecked")
List<Object[]> list = query.list();
return list;
}
}
private class CallbackBySqlQuery2 implements HibernateCallback<List<Object[]>> {
private String sql;
private Map<String, Object> params;
public CallbackBySqlQuery2(String sql, Map<String, Object> params) {
super();
this.sql = sql;
this.params = params;
}
@Override
public List<Object[]> doInHibernate(Session session) throws HibernateException {
LOGGER.info(sql);
SQLQuery query = session.createSQLQuery(sql);
Object obj;
String key;
for (Map.Entry<String, Object> entry : this.params.entrySet()) {
obj = entry.getValue();
key = entry.getKey();
if (obj instanceof Collection<?>) {
query.setParameterList(key, (Collection<?>) obj);
}
else if (obj instanceof Object[]) {
query.setParameterList(key, (Object[]) obj);
}
else {
query.setParameter(key, obj);
}
}
@SuppressWarnings("unchecked")
List<Object[]> list = query.list();
return list;
}
}
private class CallbackBySqlQuery3 implements HibernateCallback<List<Object>> {
private String sql;
private Object[] params;
public CallbackBySqlQuery3(String sql, Object[] params) {
super();
this.sql = sql;
this.params = params;
}
@Override
public List<Object> doInHibernate(Session session) throws HibernateException {
LOGGER.info(sql);
SQLQuery query = session.createSQLQuery(sql);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
@SuppressWarnings("unchecked")
List<Object> list = query.list();
return list;
}
}
private class CallbackBySqlQueryMap implements HibernateCallback<List<Map<String, Object>>> {
private String sql;
private Object[] params;
public CallbackBySqlQueryMap(String sql, Object[] params) {
super();
this.sql = sql;
this.params = params;
}
@Override
public List<Map<String, Object>> doInHibernate(Session session) throws HibernateException {
LOGGER.info(sql);
SQLQuery query = session.createSQLQuery(sql);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
//设定结果结果集中的每个对象为Map类型
query.setResultTransformer(CriteriaSpecification.ALIAS_TO_ENTITY_MAP);
@SuppressWarnings("unchecked")
List<Map<String, Object>> list = query.list();
return list;
}
}
private class CallbackBySqlDML implements HibernateCallback<Integer> {
private String sql;
private Object[] params;
public CallbackBySqlDML(String sql, Object[] params) {
super();
this.sql = sql;
this.params = params;
}
@Override
public Integer doInHibernate(Session session) throws HibernateException {
SQLQuery query = session.createSQLQuery(sql);
for (int i = 0; params != null && i < params.length; i++) {
query.setParameter(i, params[i]);
}
return query.executeUpdate();
}
}
private class CallbackFindByPageUseCriteria implements HibernateCallback<CutPage> {
private int firstResult;
private int maxResult;
private DetachedCriteria detachedCriteria;
public CallbackFindByPageUseCriteria(DetachedCriteria detachedCriteria, int firstResult, int maxResult) {
super();
this.firstResult = firstResult;
this.maxResult = maxResult;
this.detachedCriteria = detachedCriteria;
}
@Override
public CutPage doInHibernate(Session session) throws HibernateException {
CutPage cutPage = new CutPage();
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
criteria.setProjection(Projections.rowCount());
cutPage.setCount(Integer.parseInt(criteria.uniqueResult().toString()));
criteria.setProjection(null);
cutPage.setList(criteria.setMaxResults(maxResult).setFirstResult(firstResult).list());
return cutPage;
}
}
private class CallbackFindByPageUseLike implements HibernateCallback<CutPage> {
private int firstResult;
private int maxResult;
private Example example;
@SuppressWarnings("rawtypes")
private Class entityClass;
private List<Order> orderList;
private String tableAndColumn;
@SuppressWarnings("rawtypes")
public CallbackFindByPageUseLike(Example example, int firstResult, int maxResult, Class entityClass, List<Order> orderList, String tableAndColumn) {
super();
this.firstResult = firstResult;
this.maxResult = maxResult;
this.example = example;
this.entityClass = entityClass;
this.orderList = orderList;
this.tableAndColumn = tableAndColumn;
}
@Override
public CutPage doInHibernate(Session session) throws HibernateException {
CutPage cutPage = new CutPage();
Criteria criteria = session.createCriteria(entityClass).add(example);
if (tableAndColumn != null && !tableAndColumn.equals("")) {
if (tableAndColumn.contains("+")) {
int index = tableAndColumn.indexOf("+");
String tableName = tableAndColumn.substring(0, index);
if (tableName.equals("customer")) {
String columnName = tableAndColumn.substring(index + 1, tableAndColumn.length());
criteria.add(Restrictions.neOrIsNotNull(columnName, ""));
}
else if (tableName.equals("selected")) {
String columnName = tableAndColumn.substring(index + 1, tableAndColumn.length());
criteria.add(Restrictions.neOrIsNotNull(columnName, ""));
}
}
}
if (orderList != null && orderList.size() > 0) {
for (Order order : orderList) {
criteria.addOrder(order);
}
}
criteria.setProjection(Projections.rowCount());
cutPage.setCount(Integer.parseInt(criteria.uniqueResult().toString()));
criteria.setProjection(null);
cutPage.setList(criteria.setMaxResults(maxResult).setFirstResult(firstResult).list());
return cutPage;
}
}
private class CallbackFindByPageUseCriteriaX implements HibernateCallback<CutPage> {
private int firstResult;
private int maxResult;
private DetachedCriteria detachedCriteria;
private ProjectionList queryProjection;
private String distinctColumn;
private String orderColumn;
public CallbackFindByPageUseCriteriaX(DetachedCriteria detachedCriteria, int firstResult, int maxResult, ProjectionList p, String distinctColumn,
String orderColumn) {
super();
this.firstResult = firstResult;
this.maxResult = maxResult;
this.detachedCriteria = detachedCriteria;
this.queryProjection = p;
this.distinctColumn = distinctColumn;
this.orderColumn = orderColumn;
}
@Override
public CutPage doInHibernate(Session session) throws HibernateException {
CutPage cutPage = new CutPage();
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
criteria.setProjection(Projections.rowCount());
if (!StringUtils.isEmpty(distinctColumn)) {
criteria.setProjection(Projections.projectionList().add(Projections.countDistinct(distinctColumn)));
}
else {
criteria.setProjection(Projections.rowCount());
}
cutPage.setCount(Integer.parseInt(criteria.uniqueResult().toString()));
criteria.setProjection(queryProjection);
if (!StringUtils.isEmpty(orderColumn)) {
criteria.addOrder(Order.desc(orderColumn));
}
cutPage.setList(criteria.setMaxResults(maxResult).setFirstResult(firstResult).list());
return cutPage;
}
}
}