通用Hibernate-Dao

在做管理系统时。通常基于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层的代码可以复用，少了不少。

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

时间： 2024-11-07 22:27:50

通用Hibernate-Dao的相关文章

通用Hibernate DAO类(包括分页)

package com.jronline.dao; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Query; import org.hibernate.SQLQuery; import org.hibern

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  *   */ p

Hibernate Dao映射配置通用接口类反射获取加载calass实例

接口: package com.ph.dao; import java.io.Serializable; import java.util.List; import org.hibernate.criterion.DetachedCriteria; public interface BaseDao<T> { public void save(T t); public void delete(T t); public void update(T t); public T findById(Ser

hibernate dao 公共方法

1 package com.dao.impl; 2 3 import java.lang.reflect.ParameterizedType; 4 import java.util.Collection; 5 import java.util.List; 6 7 import org.hibernate.Query; 8 import org.hibernate.Session; 9 import org.hibernate.SessionFactory; 10 import org.sprin

&lt;十六&gt;JDBC_使用 DBUtils 编写通用的DAO

接口 : DAO<T>.java import java.sql.Connection;import java.sql.SQLException;import java.util.List; /* * 访问数据的DAO接口. * @param T:DAO处理的实体类的类型 * */public interface DAO<T> {  /*  * 批量处理的方法  * @param con:数据库连接  * @param sql:SQL语句  * @param args:填充占位符的

利用反射实现类通用的DAO层

public void add(Object object) throws SQLException { ResultSet rs=null; PreparedStatement ps=null; Connection con=null; //获取表名 Class c= object.getClass(); String className=c.getName(); String declareName=className.substring(className.lastIndexOf(".&q

Hibernate也需要呵护——Hibernate的泛型DAO

众所周之,面向对象的基础是抽象.也可以说,抽象促使编程在不断发展.对于数据库的访问,曾经写过HqlHelper,EFHelper.编写Spring+Hibernate框架下的应用,也同样离不了编写一个通用的泛型GenericHibernateDao.查阅了网上不少的GenericHibernateDao实现,归纳整理为如下实现,供后续编码参考. 一. DAO泛型的接口 GenericDao package ICT.framework.orm.hibernate; import java.io.S

hibernate泛化模版DAO

编写Spring+Hibernate框架下的应用,总是离不了编写一个通用的泛型GenericHibernateDao.查阅了网上不少的GenericHibernateDao实现,归纳整理为如下实现,供后续编码参考. 首先定义接口泛型DAO接口 GenericDao package com.th.huz; import java.io.Serializable; import java.util.Collection; import java.util.Iterator; import java.

Hibernate、Spring、myBatis下增删改查的Dao与DaoImpI

Hibernate Dao //Dao.java import java.util.List; /**  * @author Administrator  *   */ public interface Dao { void saveObject(Object object); void updateObject(Object object); void deleteObject(Object object); Object getObject(String HQL); List<?> fin

javaweb各种框架组合案例(七)：springboot+jdbcTemplete+通用dao+restful

一.介绍 1.springboot是spring项目的总结+整合 当我们搭smm,ssh,ssjdbc等组合框架时,各种配置不胜其烦,不仅是配置问题,在添加各种依赖时也是让人头疼,关键有些jar包之间还会出现冲突,让你的项目出现难以解决的问题.基于这种情况,springboot横空出世,在考虑到Struts控制层框架有漏洞,springboot放弃(大多数企业同样如此)了Struts,转而代之是springMVC,不过,springboot是自动集成springMVC的,不需要任何配置,不需要任