Hibernate 通用底層Dao代碼

jopen 10年前發布 | 75K 次閱讀 Hibernate 持久層框架
Hibernate 是一個非常優秀的ORM框架，能以面向對象的方式操作數據庫，使得對數據庫的操作變得更加簡單。以下和大家分享一個通用的Hibernate 編寫的底層Dao （涉及到反射）
1.反射工具類部分代碼：
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);
}

}</pre> 
2.底層Dao

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();
}

}</pre> 
 來自：http://my.oschina.net/u/1453975/blog/335645
本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！
本文地址：http://www.baiduhome.net/lib/view/open1413864078919.html
Hibernate 持久層框架
Hibernate 通用底層Dao代碼

相關經驗

相關資訊

相關文檔

目錄
