通用Hibernate-Dao

Posted 2020-08-21

在做管理系统时。通常基于Facade模式的系统持久化层要写许多Dao。这些dao里面的方法又是重复的，那么有没有什么好的方法来统一利用一个公共的Dao。 

答案是可以的。这里我们接触到JDK5.0里面的一个新特性：泛型。 

关于泛型的含义我这里就不再解释了。 

下面我们以一个对用户管理和新闻管理的来示范。 

首先是2个POJO。我这里只列出User  POJO。 
（基于注释的Pojo）

package com.oa;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
import javax.persistence.Table;  
  
@Entity  
@Table(name = "tb_user")  
public class User {  
  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)  
    private int id;  
  
    @Column(name = "username", length = 15)  
    private String username;  
  
    @Column(name = "password", length = 15)  
    private String password;  
  
    public int getId() {  
        return id;  
    }  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
    public String getUsername() {  
        return username;  
    }  
  
    public void setUsername(String username) {  
        this.username = username;  
    }  
  
    public String getPassword() {  
        return password;  
    }  
  
    public void setPassword(String password) {  
        this.password = password;  
    }  
  
}  
  
 

如果按照常规的Facade模式来设计，我们的思路是： 
先创建一个UserDao的接口。 

package com.oa.dao;  
  
import java.util.List;  
  
import com.oa.User;  
  
public interface UserDao {  
    public void save(User user);  
  
    public void delete(int id);  
  
    public void update(User user);  
  
    public List<User> query();  
  
    public User get(int id);  
  
}  
  

然后实现这个接口：UserDaoImpl 

package com.oa.dao.impl;  
  
import java.util.List;  
  
import org.springframework.context.annotation.Scope;  
import org.springframework.stereotype.Repository;  
  
import com.oa.User;  
import com.oa.dao.MyHibernateDaoSupport;  
import com.oa.dao.UserDao;  
  
  
  
/** 
 * 从Spring 2.0开始，引入了@Repository注解， 
 *  用它来标记充当储存库(又称 Data Access Object或DAO)角色或典型的类 
 */  
  
  
/** 
 * Spring 2.5引入了更多典型化注解(stereotype annotations)： @Component、@Service和 @Controller。  
 * @Component是所有受Spring管理组件的通用形式； 而@Repository、@Service和 @Controller则是@Component的细化，  
 *                   用来表示更具体的用例(例如，分别对应了持久化层、 服务层  和   表现层)。 
 */  
//@Scope("singlton")  
@Repository("userDao")//声明此类为数据持久层的类  
public class UserDaoImpl extends MyHibernateDaoSupport implements UserDao {  
  
    public void delete(int id) {  
        super.getHibernateTemplate().delete(  
                super.getHibernateTemplate().load(User.class, id));  
  
    }  
  
    public User get(int id) {  
  
        return (User) super.getHibernateTemplate().get("from  User", id);  
    }  
  
    @SuppressWarnings("unchecked")  
    public List<User> query() {  
        return super.getHibernateTemplate().find("from User");  
  
    }  
  
    public void save(User user) {  
        super.getHibernateTemplate().save(user);  
  
    }  
  
    public void update(User user) {  
        super.getHibernateTemplate().update(user);  
  
    }  
  
}  

持久化层完毕。 


接下来的是事务层 


先创建一个UserService的接口

package com.oa.service;  
  
import com.oa.User;  
  
public interface UserService {  
      
    public void save(User user);  
  
    public void update(User user);  
  
}  

然后实现这个接口：UserServiceImpl。 
在UserServiceImpl里引用UserDao来实现业务逻辑。 

package com.oa.service.impl;  
  
import com.oa.User;  
import com.oa.service.UserService;  
import com.oa.dao.UserDao;  
  
  
import java.util.List;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
  
  
  
/** 
 * 声明此类为业务逻辑层的类 
 * 默认bean名称生成器会返回小写开头的非限定(non-qualified)类名 
 * @Service 
 * userServiceImpl 
 */  
@Service("userService")  
public class UserServiceImpl implements UserService {  
  
      
    /** 
     * @Autowired 
     *  
     * @Autowired 注解可以用于"传统的"setter 方法，如下例： 
     * public void setUserDao(UserDAO userDao) 
    { 
        this.userDao = userDao; 
    } 
     */  
      
    /** 
     * @Resource有一个‘name‘属性，缺省时，Spring 将这个值解释为要注射的 bean 的名字。 
     *   @Resource(name="userDao")  
     */  
    @Autowired //  or  @Resource(name="userDao")  
    private UserDao userDao;  
  
    public void save(User user) {  
        userDao.save(user);  
  
    }  
  
    public void update(User user) {  
        userDao.update(user);  
  
    }  
  
}  
  
   

按照上面的模式：新闻管理也这么写一遍。 

重复的工作使得我们觉得好烦。 


这个时候是泛型出场的时候了。 

基于Facade的设计模式，dao和service还是要的。 这里我们就要设计一个公共的Dao..  我们称之为：GenericDao 

package com.oa.dao;  
  
import java.io.Serializable;  
import java.util.*;  
  
/** 
 * * 
 *  
 * @param <T> 
 *            泛型，指实体类  type 
 * @param <PK> 
 *            泛型，指实体类主键的数据类型，如Integer,Long 
 */  
public interface GenericDao<T, PK> {  
      
    /**   
     * 保存指定实体类   
     *    
     * @param entityobj   
     *            实体类   
     */   
    public  void save(T entity);  
      
      
      /**   
     * 删除指定实体   
     *    
     * @param entityobj   
     *            实体类   
     */    
    public void delete(T entity);  
      
      
     /** * 
     * 删除实体 
     * @param entityClass 实体类名 
     * @param id 实体的ID 
     */  
    public void deleteById(Class<T> entityClass,PK id);  
      
      
    /**   
    * 更新或保存指定实体   
    *    
    * @param entity 实体类   
    */   
    public void saveorupdate(T entity);  
      
      
     /** * 
     * 更新实体 
     * 可用于添加、修改、删除操作 
     * @param hql 更新的HQL语句 
     * @param params 参数,可有项目或多项目,代替Hql中的"?"号 
     */  
    public void update(final String hql,final Object[] params);  
      
      
  
    /**   
     * 模糊查询指定条件对象集合 <br>   
     * 用法：可以实例化一个空的T对象，需要查询某个字段，就set该字段的条件然后调用本方法<br>   
     * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重写，但没必要，其他用HQL<br>   
     *    
     * @param entity   
     *            条件实体   
     * @return 结合   
     */    
    public List<T> findByExample(T entity);  
      
      
    /**   
     * 获取所有实体集合   
     *    
     * @param entityClass   
     *            实体   
     * @return 集合   
     */    
    public List<T> findAll(Class<T> entityClass);  
      
    public List<T> findAll(Class<T> entityClass,String hql,Object[] params,int start, int limit);  
    /**   
     * 查找指定PK实体类对象   
     *    
     * @param entityClass   
     *            实体Class   
     * @param id   
     *            实体PK   
     * @return 实体对象   
     */     
    public T findById(Class<T> entityClass, PK id);  
      
    /** * 
     * 按HQL条件查询列表 
     * @param hql 查询语句,支持连接查询和多条件查询 
     * @param params 参数数组,代替hql中的"?"号 
     * @return 结果集List 
     */  
     
    public List<T> findByHql(String hql,Object[]  params);  
      
    /**   
     * 查找指定属性的实体集合   
     *    
     * @param entityClass   
     *            实体   
     * @param propertyName   
     *            属性名   
     * @param value   
     *            条件   
     * @return 实体集合   
     */    
    public List<T> findByProperty(Class<T> entityClass, String propertyName,Object value);  
      
      
    /**   
     * 查询指定HQL语句的分页数据集合   
     *    
     * @param hsql   
     *            HQL语句   
     * @param start   
     *            开始记录号   
     * @param limit   
     *            最大记录号   
     * @return 分页数据集合   
     * @throws Exception   
     *             抛出异常   
     */    
    public List<T> findByPage(Class<T> entityClass,int start,int limit) ;  
      
      
      
    /** 
     * 获得总记录数 
     */  
    public T getTotalCount(Class<T> entityClass);  
      
    public T getPageCount(String hql,Object[] params);  
  
}  
   

看到，我们不再是具体的User ， News 
。。而是用 T  来取代实体。 


因为我这个是基于 注解的，所以附上MyHibernateDaoSupport的代码。 

package com.oa.dao;  
  
import javax.annotation.Resource;  
import org.hibernate.SessionFactory;  
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  
/** 
 * 我们之所以要改写 
 * HibernateDaoSupport，是因我为，我们要为DAO层的类注入SessionFactory这个属性。 
 * 以后，我们开发的DAO类，就可以直接重用这个MyHibernateDaoSupport了。 
 * 其实，这样做是相当于配置文件方式的代码： 
 * <bean id="userDao" class="com.oa.dao.UserDaoImpl">  
 * <property 
 * name="sessionFactory" ref="sessionFactory"/>  
 * </bean> 
 *  
 * @author Administrator 
 *  
 */  
public class MyHibernateDaoSupport extends HibernateDaoSupport {  
      
    @Resource(name="sessionFactory")    //为父类HibernateDaoSupport注入sessionFactory的值  
    public void setSuperSessionFactory(SessionFactory sessionFactory){  
        super.setSessionFactory(sessionFactory);  
    }  
      
  
}  
  

到现在位置genericdao的接口有了，也就是我们要做什么。。现在就是实现它，就是怎么做。 
GenericDaoImpl 代码： 

package com.oa.dao.impl;  
  
import java.io.Serializable;  
import java.util.List;  
  
import org.hibernate.Query;  
import org.springframework.stereotype.Repository;  
  
import com.oa.dao.GenericDao;  
import com.oa.dao.MyHibernateDaoSupport;  
@SuppressWarnings("unchecked")  
@Repository("genericDao")   //声明此类为数据持久层的类  
public class GenericDaoImpl<T, PK extends Serializable> extends  
                                    MyHibernateDaoSupport implements GenericDao<T, PK> {  
  
    public void delete(T entity) {  
        super.getHibernateTemplate().delete(entity);  
    }  
  
  
    public void deleteById(Class entityClass, PK id) {  
        super.getHibernateTemplate().delete(findById(entityClass, id));  
  
    }  
      
    public void save(T entity) {  
        super.getHibernateTemplate().save(entity);  
  
    }  
  
    public void saveorupdate(T entity) {  
        super.getHibernateTemplate().saveOrUpdate(entity);  
  
    }  
  
    public void update(String hql, Object[] params) {  
             Query query = super.getSession().createQuery(hql);  
                for(int i=0; i<params.length; i++){  
                    query.setParameter(i, params[i]);  
                }  
                query.executeUpdate();  
     }  
      
  
    public List<T> findAll(Class entityClass) {  
          
        return super.getHibernateTemplate().loadAll(entityClass);  
    }  
  
    public List<T> findAll(Class entityClass, String hql, Object[] params,int start, int limit) {  
        Query query = super.getSession().createQuery(hql);  
        if(params!=null&&params.length>0){  
            for(int i = 0;i<params.length;i++){  
                query.setParameter(i, params[i]);  
            }  
        }  
        if(start!=0&&limit!=0){  
            query.setFirstResult(start).setMaxResults(limit);  
        }  
        return query.list();  
    }  
  
    public List<T> findByExample(T entity) {  
        return super.getHibernateTemplate().findByExample(entity);  
    }  
  
    public List<T> findByHql(String hql, Object[] params) {  
        Query query = super.getSession().createQuery(hql);  
        if(null!= params && params.length>0){  
            for(int i = 0; i<params.length;i++){  
                query.setParameter(i, params[i]);  
            }  
        }  
        return query.list();  
    }  
  
    public T findById(Class entityClass, PK id) {  
        return (T)super.getHibernateTemplate().get(entityClass, id);  
    }  
      
    public List<T> findByProperty(Class entityClass, String propertyName,Object value) {  
        String queryString = "from "+entityClass.getName()+ " as model where model." + propertyName + "=?";     
        return super.getHibernateTemplate().find(queryString, value);  
    }  
  
  
      
    //分页使用  
    public List<T> findByPage(Class<T> entityClass,int start,int limit) {  
          Query query=super.getSession().createQuery("select o from "+entityClass.getName()+" o");  
          query.setFirstResult(start).setMaxResults(limit);  
        return query.list();  
    }  
  
      
    public T getTotalCount(Class entityClass) {  
          
        return (T)super.getSession().createQuery("select count(o) from "+entityClass.getName()+" o").uniqueResult();  
    }  
  
    public T getPageCount(String hql, Object[] params) {  
        Query query = super.getSession().createQuery(hql);  
        if(null!= params && params.length>0){  
            for(int i = 0; i<params.length;i++){  
                query.setParameter(i, params[i]);  
            }  
        }  
        return (T)query.list();  
    }  
  
      
  
} 

至此 泛型就告一个段落。 


接下来日子就好过了。 

我们不是有user  news   等等一系列的curd管理。 


以User为例子； 
定义一个user的接口， 
UserDao.Java 

package com.oa.dao;  
  
import com.oa.User;  
  
public interface UserDao extends GenericDao<User, Integer> {  
  
public   int   login（User user）;  
//其他的方法的  
}  
  
  
然后就是实现它 UserDaoImpl  
  
package com.oa.dao.impl;  
  
  
  
import com.oa.User;  
import com.oa.dao.UserDao;  
  
public class UserDaoImpl extends GenericDaoImpl<User, Integer> implements UserDao {  
  
    public  int  login（User  user）{  
//登陆判断的方法  
  
return   XX;  
};  
  
  
//其他的方法的实现  
  
  
}  
  

持久化层就是这么多了。 

下面进入业务逻辑层，依然是先定义一个接口。 

package com.oa.service;  
  
import com.oa.User;  
  
public interface UserService {  
      
    public void save(User user);  
  
    public void update(User user);  
  
   public  int  login（User  user）；  
  
//其他的方法  
  
}  

接下来是实现 

package com.oa.service.impl;  
  
import com.oa.User;  
import com.oa.dao. UserDao;  
import com.oa.service.TestUserService;  
  
public class UserService implements UserService {  
  
    private  UserDao  UserDao;  
    public void save(User user) {  
        UserDao.save(user);  
  
    }  
  
    public void updasaveorupdatete(User user) {  
        UserDao.saveorupdate(user);  
  
    }  
  
    public int   login(User user) {  
        return   UserDao.login(user);  
  
    }  
  
//其他的方法。。。。  
  
}  

Ok。。到现在我们就利用泛型dao来设计就完毕了 

两者相对比，发现dao层的代码可以复用，少了不少。 

对于大型管理系统，效果更明显。