hibernate ---- 通过泛型配置 DAO

来源于自己的一些见解，与网上所找到的一些解释，可能注释的理解部分并不会很全面和正确

package com.test.dao;

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

/**
 * 基础dao接口
 * @author Ming
 * @date 2017/11/16 12:46
 */
 // 一个entity user，其主键 id 为 Integer 类型，那么这里就可以BaseDao
public interface BaseDaoextends Serializable> {

    /**
     * 根据主键进行查询
     * @param id
     * @return
     */
    T get(PK id);

    /**
     * 查询所有
     * @return
     */
    List getAll();

    /**
     * 保存
     * @param entity
     */
    void save(T entity);

    /**
     * 根据主键删除
     * @param id
     */
    void delete(PK id);

    /**
     * 修改
     * @param entity
     */
    void update(T entity);

    /**
     * 修改or新增
     * @param entity
     */
    void saveOrUpdate(T entity);

    /**
     * 数据条数
     * @param hql
     * @return
     */
    Integer getSize(String hql);
}

package com.test.dao.impl;


import com.test.dao.BaseDao;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

/**
 *继承dao的实现
 * @author Ming
 * @date 2017/11/16 12:46
 */
@Repository
public class BaseDaoImpl<T, PK extends Serializable> implements BaseDao<T, PK> {

//    DAO 层继承 HibernateDaoSupport , 因为 HibernareDaoSupport 有个属性就是 sessionFactory
//    把sessionfactory赋给HibernateDaoSupprot中的sessionfactory,只有这样我们才能任意的使用HibernateDaoSupport中的任何方法
    @Resource
    private SessionFactory sessionFactory;
    //实际类型的Class对象
    private Class entityClass;

    public BaseDaoImpl() {
//        返回一个包含某些 Class 对象，这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口。
        Class clz = getClass();
//        返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type
        Type type = clz.getGenericSuperclass();
//        instanceof进行类型检查规则是:你属于该类吗？或者你属于该类的派生类吗？而通过getClass获得类型信息采用==来进行检查是否相等的操作是严格的判断。不会存在继承方面的考虑
//        ParameterizedType 表示参数化类型，如 Collection。
        if (type instanceof ParameterizedType) {
            //获取实际参数类型的数组
            Type[] types = ((ParameterizedType) type).getActualTypeArguments();
            entityClass = (Class) types[0];
        }
    }

    /**
     * 获取Session的方法
     * 使用sessionFactory.getCurrentSession()：需要将使用的方法加入事务管理中。
     * 创建的session会绑定到当前线程，事物结束后自动将session从当前线程中释放，并且关闭session。
     * 
     * sessionFactory.openSession()：每次都打开一个新的session，而且在事物结束后，不会自动关闭，所以要手动关闭
     * 
     * 在一个应用程序中，如果DAO 层使用Spring 的hibernate 模板，通过Spring 来控制session 的生命周期，
     * 则首选getCurrentSession ()。
     * 
     * @return
     */
    public Session getSession() {
        return sessionFactory.getCurrentSession();
    }

    @Override
    public T get(PK id) {
        return (T) getSession().get(entityClass, id);
    }

    @Override
    public List getAll() {
        Query query = getSession().createQuery("from " + entityClass.getName());//from TableName
        return (List) query.list();
    }

    @Override
    public void save(T entity) {
        getSession().save(entity);
        getSession().flush();
    }

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

    /**
     * .fiush() 清理缓存,执行SQL。
     * @param entity
     */
    @Override
    public void delete(PK id) {
        T entity = get(id);
        getSession().delete(entity);
        getSession().flush();
    }

    @Override
    public void update(T entity) {
        getSession().update(entity);
        getSession().flush();
    }

    @Override
    public Integer getSize(String hql) {
        Query query = getSession().createQuery(hql);
        return query.list().size();
    }
}