Hibernate 通用底層Dao
1.反射工具類 部分代碼：java
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 反射的 Utils 函數集合 提供訪問私有變量, 獲取泛型類型 Class, 提取集合中元素屬性等 Utils 函數
*
* @author Administrator
*
*/
public class ReflectionUtils {
private static Logger logger = LoggerFactory.getLogger(ReflectionUtils.class);
/**
* 經過反射, 得到定義 Class 時聲明的父類的泛型參數的類型 如: public EmployeeDao extends
* BaseDao<Employee, String>
*
* @param clazz
* @param index
* @return
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(Class clazz, int index) {
Type genType = clazz.getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
logger.warn(clazz.getSimpleName()
+ "'s superclass not ParameterizedType");
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
logger.warn("Index: " + index + ", Size of "
+ clazz.getSimpleName() + "'s Parameterized Type: "
+ params.length);
return Object.class;
}
if (!(params[index] instanceof Class)) {
logger.warn(clazz.getSimpleName()
+ " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class) params[index];
}
/**
* 經過反射, 得到 Class 定義中聲明的父類的泛型參數類型 如: public EmployeeDao extends
* BaseDao<Employee, String>
*
* @param <T>
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> getSuperGenericType(Class clazz) {
return getSuperClassGenricType(clazz, 0);
}
}
2.底層Daospring
import java.io.Serializable;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Resource;
import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.hibernate.metadata.ClassMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;
/**
* 在 Service 層直接使用, 也能夠擴展泛型 DAO 子類使用 T: Dao 操做的對象類型 PK: 主鍵類型
*
* @author Administrator
*
*/
public class SimpleHibernateDao<T, PK extends Serializable> {
protected Logger logger = LoggerFactory.getLogger(getClass());
protected SessionFactory sessionFactory;
protected Class<T> entityClass;
/**
* 用於 Dao 層子類使用的構造函數 經過子類的泛型定義取得對象類型 Class
*
* 例如: public class UserDao extends SimpleHibernateDao<User, String>
*/
public SimpleHibernateDao() {
this.entityClass = ReflectionUtils.getSuperGenericType(getClass());
}
/**
* 用於省略 Dao 層, 在 Service 層直接使用通用 SimpleHibernateDao 的構造函數 在構造函數中定義對象類型 Class
*
* @param sessionFactory
* @param entityClass
*/
public SimpleHibernateDao(SessionFactory sessionFactory,
Class<T> entityClass) {
this.sessionFactory = sessionFactory;
this.entityClass = entityClass;
}
public SessionFactory getSessionFactory() {
return sessionFactory;
}
@Resource
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
/**
* 獲取當前 Session
* @return
*/
public Session getSession() {
Session session = sessionFactory.getCurrentSession();
return session;
// return sessionFactory.openSession();
}
/**
* 保存新增或修改的對象
*
* @param entity
*/
public void save(T entity) {
Assert.notNull(entity, "entity 不能爲空");
getSession().saveOrUpdate(entity);
logger.debug("save entity: {}", entity);
}
/**
* 按 id 獲取對象
*
* @param id
* @return
*/
@SuppressWarnings("unchecked")
public T get(PK id) {
Assert.notNull(id, "id不能爲空");
return (T) getSession().get(entityClass, id);
}
/**
* 刪除對象
*
* @param entity： 持久化對象或"瞬態"對象
*/
public void delete(T entity) {
Assert.notNull(entity, "entity 不能爲空");
getSession().delete(entity);
logger.debug("delete entity: {}", entity);
}
public void delete(PK id) {
Assert.notNull(id, "id 不能爲空");
delete(get(id));
logger.debug("delete entity {},id is {}", entityClass.getSimpleName(),
id);
}
/**
* 獲取對象的主鍵名.
*
* @return
*/
public String getIdName() {
ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
return meta.getIdentifierPropertyName();
}
/**
* 經過 Set 將不惟一的對象列表惟一化 主要用於 HQL/Criteria 預加載關聯集合造成重複記錄, 又不方便使用 distinct
* 查詢語句時: 例如: 迫切左外鏈接
*
* @param <X>
* @param list
* @return
*/
@SuppressWarnings("unchecked")
public <X> List<X> distinct(List list) {
Set<X> set = new LinkedHashSet<X>(list);
return new ArrayList<X>(set);
}
/**
* 爲 Criteria 添加 distinct transformer
*
* @param criteria
* @return
*/
public Criteria distinct(Criteria criteria) {
criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return criteria;
}
/**
* 爲 Query 添加 distinct transformer
*
* @param query
* @return
*/
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return query;
}
/**
* 初始化對象. 使用 load() 方法獲得的僅是對象的代理, 在傳到視圖層前須要進行初始化
*
* 只初始化 entity 的直接屬性, 但不會初始化延遲加載的關聯集合和屬性 如需初始化關聯屬性, 可執行:
* Hibernate.initialize(user.getRoles());
*
* @param entity
*/
public void initEntity(T entity) {
Hibernate.initialize(entity);
}
public void initEntity(List<T> entityList) {
for (T entity : entityList) {
Hibernate.initialize(entity);
}
}
/**
* 根據 Criterion 條件建立 Criteria
*
* @param criterions
* @return
*/
public Criteria createCriteria(Criterion... criterions) {
Criteria criteria = getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
/**
* 按 Criteria 查詢惟一對象
*
* @param criterions: 數量可變的 Criterion
* @return
*/
public T findUnique(Criterion... criterions) {
return (T) createCriteria(criterions).uniqueResult();
}
/**
* 按 Criteria 查詢對象列表
*
* @param criterions
* : 數量可變的 Criterion
* @return
*/
@SuppressWarnings("unchecked")
public List<T> find(Criterion... criterions) {
return createCriteria(criterions).list();
}
/**
* 根據查詢 HQL 與參數列表建立 Query 對象
*
* @param queryString
* @param values
* @return
*/
public Query createQuery(String queryString, Map<String, Object> values) {
// String hql = "FROM Employee e where e.loginname = :loginname";
Assert.hasText(queryString, "queryString不能爲空");
Query query = getSession().createQuery(queryString);
if (values != null) {
query.setProperties(values);
}
return query;
}
/**
* 根據查詢 HQL 與參數列表建立 Query 對象
*
* @param queryString
* @param values
* : 數來那個可變的參數, 按順序綁定
* @return
*/
public Query createQuery(String queryString, Object... values) {
Assert.hasText(queryString, "queryString不能爲空");
Query query = getSession().createQuery(queryString);
if (values != null) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
}
return query;
}
/**
* 執行 hql 進行批量修改/刪除操做
*
* @param hql
* @param values
* @return
*/
public int batchExecute(String hql, Map<String, Object> values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 執行 hql 進行批量修改/刪除操做
*
* @param hql
* @param values
* @return
*/
public int batchExecute(String hql, Object... values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 按 HQL 查詢惟一對象
*
* @param <X>
* @param hql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public <X> X findUnique(String hql, Map<String, Object> values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 按 HQL 查詢惟一對象
*
* @param <X>
* @param hql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public <X> X findUnique(String hql, Object... values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 按 HQL 查詢對象列表
*
* @param <X>
* @param hql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public <X> List<X> find(String hql, Map<String, Object> values) {
return createQuery(hql, values).list();
}
/**
* 按 HQL 查詢對象列表
*
* @param <X>
* @param hql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public <X> List<X> find(String hql, Object... values) {
return createQuery(hql, values).list();
}
/**
* 按 id 列表獲取對象列表
*
* @param ids
* @return
*/
public List<T> findByIds(List<?> ids) {
return find(Restrictions.in(getIdName(), ids));
}
/**
* 按屬性查找惟一對象, 匹配方式爲相等
*
* @param propertyName
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public T findUniqueBy(String propertyName, Object value) {
Assert.hasText(propertyName, "propertyName不能爲空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteria(criterion).uniqueResult();
}
/**
* 按屬性查找對象列表, 匹配方式爲相等
*
* @param propertyName
* @param value
* @return
*/
public List<T> findBy(String propertyName, Object value) {
Assert.hasText(propertyName, "propertyName不能爲空");
Criterion criterion = Restrictions.eq(propertyName, value);
return find(criterion);
}
/**
* 獲取所有對象
*
* @return
*/
public List<T> getAll() {
return find();
}
}
相關文章
- 1. hibernate底層dao封裝
- 2. 通用Hibernate-Dao
- 3. Hibernate dao 層
- 4. Hibernate的Dao層與接口
- 5. Hibernate的dao層排錯
- 6. SSH之Hibernate的Dao層和Service層
- 7. 05.hibernate通用dao層實現增刪改查
- 8. Dao層系列-4-Hibernate Spring Annotation
- 9. Dao層系列-3-Hibernate Spring Intergration
- 10. mybaits之dao層通用寫法sqlsessiontemplate
- 更多相關文章...
- • SQL 通用數據類型 - SQL 教程
- • SQL 通配符 - SQL 教程
- • Composer 安裝與使用
- • 使用Rxjava計算圓周率
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
