Hibernate通用Dao

1. 接口

package com.coder163.main.dao;

import org.hibernate.criterion.DetachedCriteria;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

/**
 * 功能描述: Hibernate通用的持久层接口
 *
 * @author 侯叶飞
 * @create 2018-04-12 14:24
 **/
public interface BaseDaoI<T> {

    /**
     * 保存
     *
     * @param entity 对象
     *
     * @return id
     */
     Serializable save(T entity);
    /**
     * 将实体对象 集合保存到数据库中
     *
     * @param collection
     *            实体对象 集合
     */
     void saveAll(Collection<T> collection);

    /**
     * 更新
     *
     * @param entity 对象
     */
     void update(T entity);

    /**
     * 保存或更新
     *
     * @param entity 对象
     */
     void saveOrUpdate(T entity);

    /**
     * 删除
     *
     * @param entity 删除的对象
     */
     void delete(T entity);

    /**
     * 通过对象标识符获取对象
     *
     * @param id 主键
     * @return 标识符对应的对象，没找到则返回null
     */
     T findById(Serializable id);

    /**
     * 返回所有对象的列表
     *
     * @return
     */
     List<T> findAll();

    /**
     * 查找满足条件的总记录数
     *
     * @param detachedCriteria 查询条件
     * @return
     */
    Integer findRecordNumByPage(DetachedCriteria detachedCriteria);

    /**
     * 向分页对象中设置记录
     *
     * @param detachedCriteria
     *            离线查询对象
     * @param startIndex
     *            开始索引
     * @param pageSize
     *            每页记录数
     * @return
     */
    List<T> findByPage(DetachedCriteria detachedCriteria, Integer startIndex, Integer pageSize);

    /**
     * 通过条件查询
     *
     * @param detachedCriteria
     * @return
     */
    List<T> findByCriteria(DetachedCriteria detachedCriteria);

    /**
     * 通用更新方法
     *
     * @param queryName
     *            命名查询的名字，在映射文件中定义
     * @param objects
     *            参数列表
     */
     void executeUpdate(String queryName, Object... objects);

    /**
     * 按条件统计
     * @param deCriteria
     * @return
     */
    Integer count(DetachedCriteria deCriteria);
}

2. 实现类

package com.coder163.main.dao;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;

/**
 * 功能描述: Hibernate通用持久层接口实现类
 *
 * @author 侯叶飞
 * @date 2018-04-12 14:30
 **/
public class BaseDaoImpl<T>  extends HibernateDaoSupport implements BaseDaoI<T> {
    // 存储泛型的实际参数
    private Class entity;

    public BaseDaoImpl() {
        // 谁实现该类，这就是谁的类字节码
        Class c = this.getClass();
        // 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type
        Type type = c.getGenericSuperclass();
        // 将类型强转为参数化类型
        ParameterizedType pType = (ParameterizedType) type;
        // 获取该类的父类的所有实际类型参数，也就是泛型的实际参数
        // 这里也就是获取BaseDaoImpl的实际类型参数
        Type[] actualTypeArguments = pType.getActualTypeArguments();
        // 将实际类型参数赋值给成员变量
        entity = (Class) (actualTypeArguments[0]);
    }

    @Override
    public Serializable save(T entity) {
        return this.getHibernateTemplate().save(entity);
    }

    @Override
    public void saveAll(Collection<T> collection) {
        for (T t : collection) {
            this.getHibernateTemplate().save(t);
        }
    }

    @Override
    public void update(T entity) {
        this.getHibernateTemplate().update(entity);
    }

    @Override
    public void saveOrUpdate(T entity) {
        this.getHibernateTemplate().saveOrUpdate(entity);
    }

    @Override
    public void delete(T entity) {
        this.getHibernateTemplate().delete(entity);
    }

    @Override
    public T findById(Serializable id) {
        return (T) this.getHibernateTemplate().get(this.entity, id);
    }
    @Override
    public List<T> findAll() {
        StringBuffer hql = new StringBuffer("from ");

        hql.append(entity.getName());

        return this.getHibernateTemplate().find(hql.toString());
    }

    @Override
    public Integer findRecordNumByPage(DetachedCriteria detachedCriteria) {
        // 设置记录数投影
        detachedCriteria.setProjection(Projections.rowCount());
        List<Long> list = (List<Long>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
        // 将投影置为空
        detachedCriteria.setProjection(null);
        if (list.size() > 0) {
            return list.get(0).intValue();
        }
        return null;
    }

    @Override
    public List<T> findByPage(DetachedCriteria detachedCriteria, Integer startIndex, Integer pageSize) {
        // 指定hibernate在连接查询时，只封装成一个对象
        detachedCriteria.setResultTransformer(DetachedCriteria.ROOT_ENTITY);
        return (List<T>) this.getHibernateTemplate().findByCriteria(detachedCriteria, startIndex, pageSize);
    }

    @Override
    public List<T> findByCriteria(DetachedCriteria detachedCriteria) {
        return (List<T>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
    }

    @Override
    public void executeUpdate(String queryName, Object... objects) {
        // 获取当前session
        Session session = this.getSessionFactory().getCurrentSession();
        // 获取命名查询对象
        Query query = session.getNamedQuery(queryName);
        int i = 0;
        // 设置参数
        if (objects != null) {
            for (Object object : objects) {
                query.setParameter(i++, object);
            }
        }
        query.executeUpdate();
    }

    @Override
    public Integer count(DetachedCriteria deCriteria) {
        deCriteria.setProjection(Projections.rowCount());
        return Integer.parseInt(deCriteria.getExecutableCriteria(this.getSession()).uniqueResult().toString());
    }
}

转载于:https://www.cnblogs.com/coder163/p/9007597.html