package org.slave4j.utils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.transform.ResultTransformer;
import org.slave4j.orm.Compositor;
import org.slave4j.orm.Filtration;
import org.slave4j.orm.PageData;
import org.slave4j.orm.Filtration.MatchType;
import org.slave4j.orm.Compositor.CompositorType;
import org.slave4j.orm.hibernate.BaseEntity;
import org.springframework.util.Assert;
/**
* hibernate工具類
*
*/
public class HibernateUtils
{
/**
* 根據Criterion條件建立Criteria.
*/
public static Criteria createCriteria(Session session, Class<? extends BaseEntity> entityClass,
Criterion... criterions)
{
Criteria criteria = session.createCriteria(entityClass);
for (Criterion criterion : criterions)
{
criteria.add(criterion);
}
return criteria;
}
/**
* 根據查詢HQL與參數清單建立Query對象.
*/
public static Query createQuery(Session session, String hql, Object... values)
{
Assert.hasText(hql, "hql不能為空");
Query query = session.createQuery(hql);
for (int i = 0; i < values.length; i++)
{
query.setParameter(i, values[i]);
}
return query;
}
/**
* 根據查詢HQL與參數清單建立Query對象.
*/
public static Query createQuery(Session session, String hql, Map<String, ?> values)
{
Assert.hasText(hql, "hql不能為空");
Query query = session.createQuery(hql);
if (values != null)
{
query.setProperties(values);
}
return query;
}
/**
* 建立Criterion
*/
private static Criterion createCriterion(String fieldName, Object fieldValue, MatchType matchType)
{
Criterion criterion = null;
Assert.hasText(fieldName, "fieldName不能為空");
switch (matchType)
{
case EQ: // =
criterion = Restrictions.eq(fieldName, fieldValue);
break;
case LIKE: // like
criterion = Restrictions.like(fieldName, (String) fieldValue, MatchMode.ANYWHERE);
break;
case LT: // <
criterion = Restrictions.lt(fieldName, fieldValue);
break;
case LE: // <=
criterion = Restrictions.le(fieldName, fieldValue);
break;
case GT: // >
criterion = Restrictions.gt(fieldName, fieldValue);
break;
case GE: // >=
criterion = Restrictions.ge(fieldName, fieldValue);
break;
}
return criterion;
}
/**
* 執行count查詢獲得本次Criteria查詢所能獲得的對象總數.
*/
@SuppressWarnings("unchecked")
private static long countCriteriaResult(Criteria criteria)
{
CriteriaImpl impl = (CriteriaImpl) criteria;
// 先把Projection、ResultTransformer、OrderBy取出來,清空三者後再執行Count操作
Projection projection = impl.getProjection();
ResultTransformer resultTransformer = impl.getResultTransformer();
List<CriteriaImpl.OrderEntry> orderEntries = null;
orderEntries = (List) ReflectionUtils.getFieldValue(impl, "orderEntries");
ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList());
// 執行Count查詢
Object object = criteria.setProjection(Projections.rowCount()).uniqueResult();
long totalCount = 0;
if (object instanceof Integer)
{
totalCount = ((Integer) object).longValue();
}
else
{
totalCount = (Long) object;
}
// 将之前的Projection,ResultTransformer和OrderBy條件重新設回去
criteria.setProjection(projection);
if (projection == null)
{
criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
}
if (resultTransformer != null)
{
criteria.setResultTransformer(resultTransformer);
}
ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
return totalCount;
}
/**
* 設定排序參數到Criteria對象
*/
public static Criteria setCompositorParameter(Criteria criteria, Compositor compositor)
{
if (compositor != null)
{
String fieldName = compositor.getFieldName();
CompositorType compositorType = compositor.getCompositorType();
switch (compositorType)
{
case ASC:
criteria.addOrder(Order.asc(fieldName));
break;
case DESC:
criteria.addOrder(Order.desc(fieldName));
break;
}
}
return criteria;
}
/**
* 設定過濾條件到Criteria對象
*/
public static Criteria setFiltrationParameter(Criteria criteria, Filtration... filtrations)
{
if (filtrations.length > 0)
{
List<Criterion> criterions = new ArrayList<Criterion>();
for (Filtration filtration : filtrations)
{
Criterion criterion = null;
if (!filtration.isMultiFilter())
{
criterion = createCriterion(filtration.getFieldName(), filtration.getFieldValue(), filtration
.getMatchType());
criterions.add(criterion);
}
else
{
// 包含多個屬性需要比較的情況,進行or處理.
Disjunction disjunction = Restrictions.disjunction();
for (String filedName : filtration.getFieldNames())
{
criterion = createCriterion(filedName, filtration.getFieldValue(), filtration
.getMatchType());
disjunction.add(criterion);
}
criterions.add(disjunction);
}
}
for (Criterion criterion : criterions)
{
criteria.add(criterion);
}
}
return criteria;
}
/**
* 設定過濾條件到Criteria對象
*/
public static Criteria setFiltrationParameter(Criteria criteria, List<Filtration> filtrationList)
{
if (filtrationList != null)
{
// Filtration[] filtrations = (Filtration[]) filtrationList.toArray();
Filtration[] filtrations = new Filtration[filtrationList.size()];
for (int i = 0; i < filtrationList.size(); i++)
{
filtrations[i] = filtrationList.get(i);
}
return setFiltrationParameter(criteria, filtrations);
}
else
{
return criteria;
}
}
/**
* 設定分頁參數到Criteria對象
*/
public static Criteria setParameter(Criteria criteria, PageData<?> pageData)
{
// 第一步：設定查詢條件
setFiltrationParameter(criteria, pageData.getFiltrations());
// 第二步：讀取記錄總數
if (pageData.getPagination().isReadTotalCount())
{
long totalCount = countCriteriaResult(criteria);
pageData.getPagination().setTotalCount(totalCount);
}
// 第三步：設定查詢範圍
criteria.setFirstResult(pageData.getPagination().getCurrentlyPageFirstResoultIndex());
criteria.setMaxResults(pageData.getPagination().getPageSize());
// 排序條件
setCompositorParameter(criteria, pageData.getCompositor());
return criteria;
}
}
package org.slave4j.orm.hibernate;
import java.util.Date;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.slave4j.orm.Compositor;
import org.slave4j.orm.Filtration;
import org.slave4j.orm.PageData;
import org.slave4j.utils.HibernateUtils;
import org.slave4j.utils.ReflectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;
/**
* dao基類.
* 1：該類封裝了最常見資料庫操作的方法，你可以繼承該類，添加自己喜歡的方法
* 2：當你有多個sessionFactory時，你也可以在你的子類中重寫setSessionFactory()方法
* @param <T> 實體類類型
*/
@SuppressWarnings("unchecked")
public class BaseDao<T extends BaseEntity>
{
protected Logger logger = LoggerFactory.getLogger(getClass());
protected SessionFactory sessionFactory;
protected Class<T> entityClass;
/**
* 構造方法
*/
public BaseDao()
{
this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
}
/**
* 采用@Resource(name="xxx")按名稱注入SessionFactory, 當有多個SesionFactory的時候Override本函數.
*/
@Resource
public void setSessionFactory(SessionFactory sessionFactory)
{
this.sessionFactory = sessionFactory;
}
/**
* 取得Session.
*/
public Session getSession()
{
return sessionFactory.getCurrentSession();
}
//--------------------------------------------------------------------------------------------------
/**
* 新增對象.
*/
public void save(T entity)
{
Assert.notNull(entity, "entity不能為空");
entity.setInsertTime(new Date());//插入時間
getSession().save(entity);
logger.debug("save entity: {}", entity);
}
/**
* 修改對象.
*/
public void update(T entity)
{
Assert.notNull(entity, "entity不能為空");
entity.setLastUpdateTime(new Date());//最後一次修改時間
getSession().update(entity);
logger.debug("update entity: {}", entity);
}
/**
* 删除對象.
*/
public void delete(T entity)
{
Assert.notNull(entity, "entity不能為空");
getSession().delete(entity);
logger.debug("delete entity: {}", entity);
}
/**
* 删除對象.
*/
public void delete(Integer id)
{
delete(find(id));
logger.debug("delete entity {},id is {}", entityClass.getSimpleName(), id);
}
/**
* 對象顯示.
*/
public void visible(Integer id)
{
T entity = find(id);
Assert.notNull(entity, "entity不能為空");
if(!entity.isVisible())
{
entity.setVisible(true);
update(entity);
logger.debug("visible entity {},id is {}", entityClass.getSimpleName(), id);
}
}
/**
* 對象不顯示.
*/
public void unVisible(Integer id)
{
T entity = find(id);
Assert.notNull(entity, "entity不能為空");
if(entity.isVisible())
{
entity.setVisible(false);
update(entity);
logger.debug("unVisible entity {},id is {}", entityClass.getSimpleName(), id);
}
}
/**
* 按id擷取對象.
*/
public T find(Integer id)
{
Assert.notNull(id, "id不能為空");
return (T) getSession().load(entityClass, id);
}
/**
* 按屬性查找唯一對象,比對方式為相等.
*/
public T find(String fieldName, Object fieldValue)
{
Assert.hasText(fieldName, "fieldName不能為空");
Criterion criterion = Restrictions.eq(fieldName, fieldValue);
return (T) HibernateUtils.createCriteria(getSession(), entityClass, criterion).uniqueResult();
}
/**
* 按屬性查找對象清單,比對方式為相等.
*/
public List<T> findList(String fieldName, Object fieldValue)
{
Assert.hasText(fieldName, "fieldName不能為空");
Criterion criterion = Restrictions.eq(fieldName, fieldValue);
return HibernateUtils.createCriteria(getSession(), entityClass, criterion).list();
}
/**
* 按照過濾條件對象查找對象清單.
*/
public List<T> findList(Filtration... filtrations)
{
Criteria criteria = HibernateUtils.createCriteria(getSession(), entityClass);
//設定過濾條件
criteria = HibernateUtils.setFiltrationParameter(criteria, filtrations);
return criteria.list();
}
/**
* 按照過濾條件對象查找對象清單.
*/
public List<T> findList(List<Filtration> filtrationList)
{
Criteria criteria = HibernateUtils.createCriteria(getSession(), entityClass);
//設定過濾條件
criteria = HibernateUtils.setFiltrationParameter(criteria, filtrationList);
return criteria.list();
}
/**
* 按照過濾條件對象查找對象清單，支援排序.
*/
public List<T> findList(Compositor compositor, Filtration... filtrations)
{
Criteria criteria = HibernateUtils.createCriteria(getSession(), entityClass);
//設定過濾條件
criteria = HibernateUtils.setFiltrationParameter(criteria, filtrations);
//設定排序
criteria = HibernateUtils.setCompositorParameter(criteria, compositor);
return criteria.list();
}
/**
* 按照過濾條件對象查找對象清單，支援排序.
*/
public List<T> findList(Compositor compositor, List<Filtration> filtrationList)
{
Criteria criteria = HibernateUtils.createCriteria(getSession(), entityClass);
//設定過濾條件
criteria = HibernateUtils.setFiltrationParameter(criteria, filtrationList);
//設定排序
criteria = HibernateUtils.setCompositorParameter(criteria, compositor);
return criteria.list();
}
/**
* 擷取全部對象.
*/
public List<T> findAll()
{
return findList();
}
/**
* 擷取全部對象,支援排序.
*/
public List<T> findAll(Compositor compositor)
{
return findList(compositor);
}
/**
* 分頁查詢.
*/
public PageData<T> find(PageData<T> pageData)
{
Assert.notNull(pageData, "pageData不能為空");
Criteria criteria = HibernateUtils.createCriteria(getSession(), entityClass);
HibernateUtils.setParameter(criteria, pageData);
pageData.setResult(criteria.list());
return pageData;
}
/**
* 按id清單擷取對象.
*/
public List<T> findListByIds(List<Integer> idList)
{
if (idList != null && idList.size() >= 1)
{
Criterion criterion = Restrictions.in("id", idList);
return HibernateUtils.createCriteria(getSession(), entityClass, criterion).list();
} else
{
return null;
}
}
//--------------------------------------------------------------------------------------------------
/**
* 按HQL查詢唯一對象.
* @param hql "from Users where name=? and password=?"
* @param values 數量可變的參數,按順序綁定.
* @return
*/
public <X> X find(String hql, Object... values)
{
return (X) HibernateUtils.createQuery(getSession(), hql, values).uniqueResult();
}
/**
* 按HQL查詢唯一對象.
* @param hql "from Users where name=:name and password=:password"
* @param values 命名參數,按名稱綁定.
* @return
*/
public <X> X find(String hql, Map<String, ?> values)
{
return (X) HibernateUtils.createQuery(getSession(), hql, values).uniqueResult();
}
/**
* 按HQL查詢對象清單.
* @param hql "from Users where name=? and password=?"
* @param values 數量可變的參數,按順序綁定.
* @return
*/
public <X> List<X> findList(String hql, Object... values)
{
return HibernateUtils.createQuery(getSession(), hql, values).list();
}
/**
* 按HQL查詢對象清單.
* @param hql "from Users where name=:name and password=:password"
* @param values 命名參數,按名稱綁定.
* @return
*/
public <X> List<X> findList(String hql, Map<String, ?> values)
{
return HibernateUtils.createQuery(getSession(), hql, values).list();
}
/**
* 執行HQL進行批量修改/删除操作.
* @return 更新記錄數.
*/
public int batchExecute(String hql, Object... values)
{
return HibernateUtils.createQuery(getSession(), hql, values).executeUpdate();
}
/**
* 執行HQL進行批量修改/删除操作.
* @return 更新記錄數.
*/
public int batchExecute(String hql, Map<String, ?> values)
{
return HibernateUtils.createQuery(getSession(), hql, values).executeUpdate();
}
//--------------------------------------------------------------------------------------------------
/**
* 本地SQL進行修改/删除操作.
* @return 更新記錄數.
*/
public List find(String sql)
{
Assert.hasText(sql, "sql不能為空");
return getSession().createSQLQuery(sql).list();
}
}
使用方法
Compositor compositor = new Compositor("deliverWebRequest", CompositorType.DESC);
List<Filtration> filtrations = new ArrayList<Filtration> ();
Filtration filtration = new Filtration(MatchType.EQ, 0, "logicDel");
filtrations.add(filtration);
l=((ShopDao) this.baseDao).findList(compositor, filtrations); 捐助開發者
在興趣的驅動下,寫一個
免費
的東西，有欣喜，也還有汗水，希望你喜歡我的作品，同時也能支援一下。 當然，有錢捧個錢場（右上角的愛心标志，支援支付寶和PayPal捐助），沒錢捧個人場，謝謝各位。
謝謝您的贊助，我會做的更好！