`

数据库访问层中使用GenericDao和HibernateDaoSupport

 
阅读更多

1.参考文献

  1).SSH实例:基于HibernateDaoSupport的泛型Dao

  2).GenericDao设计模式

  3).Generic Data Access Objects

open source project:

  4).genericdao

  5).hibernate-generic-dao

2.问题

  含有多个pojo实体,每一个pojo都要写一个PojoDAO,非常乏味枯燥,思考有没有一种通过的DAO能够省去为每一个pojo写一个DAO。

3.GenericDao分析

  GenericDao的目的是通过他来实现通用的数据库访问层,它通过泛型来实现不同pojo也能够使用一个GenericDao来进行访问,只需要设置泛型的类型即可。首先来看一看GenericDao整体结构。

图1:GenericDao结构图

ps:2011-12-28

  今天给eclipse安装了GreenUML这个eclipse插件,在eclipse中通过如下网址:http://www.cse.buffalo.edu/faculty/alphonce/green更新插件即可。GreenUML能够根据代码生成UML图,所以我将GenericDao结构生成UML如下:

下面来解释上面每一个类或者接口的用户

  1. GenericDao<T>:泛型接口,在这里定义了Dao层的基础的CRUD(Create, read, update and delete)方法,比如sava保存实例,delete删除实例等等。
  2. HibernateDaoSupport:这个是由spring提供的一个抽象类:org.springframework.orm.hibernate3.support.HibernateDaoSupport。类里面定义了 HibernateTemplate的实例,是hibernate的ORM结构中最基础的一个类。
  3. HibernateGenericDao:这个类在我们的例子中没有定义任何方法与变量,他的主要的用处是:(1)重写(Override)HibernateDaoSupport 中定义的方法;(2)增加一些对HibernateDaoSupport类的补充。
  4. GenericDaoImplHibernate<T>:这个类继承HibernateGenericDao并实现接口GenericDao<T>
  5. FileDao:数据访问层接口,根据需求定义方法。
  6. FileDaoImpl:实例化的数据库访问层接口FileDao,并继承通用数据库访问层的类。这样如果FileDao中没有定义方法,那么就表明通用数据库访问层GenericDaoImplHibernate已经能够满足需要。

  上面的结构图看上去有点负责,其实是因为这样的接口充分考虑了系统的可扩充性。如果不考虑可扩充性的话,那么像FileDao、FileDaoImpl和HibernateGenericDao都可以去掉,直接让GenericDaoImplHibernate<T>实现GenericDao<T>接口并继承HibernateDaoSupport类就可以了。在后在使用的时候实例化Dao对象,比如:

GenericDaoImplHibernate<User> userDao=new GenericDaoImplHibernate<User>()

4.GenericDao代码实例

根据GenericDao结构图给出各个接口与类的代码。

4.1.GenericDao.java

复制代码
import java.io.Serializable;
import java.util.List;

public interface GenericDao<T> {
    public void save(Object o);//保存    
    void delete(Object o);//删除修改
    void deleteById(Serializable id);    
    public void update(Object o);//
    public void saveOrUpdate(Object o);
    
    public T getById(Serializable id);//查询
    public List<T> findAll(Class<T> entityClass);
    public List<T> findByExample(Object o);
    //...
}
复制代码

4.2.HibernateDaoSupport.java

这个其实只需要导入spring.jar包即可,不过这里我还是贴出它的源代码,以供参考

复制代码
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.dao.support.DaoSupport;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
public abstract class HibernateDaoSupport extends DaoSupport {

    private HibernateTemplate hibernateTemplate;

    public final void setSessionFactory(SessionFactory sessionFactory) {
      this.hibernateTemplate = createHibernateTemplate(sessionFactory);
    }

    protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
        return new HibernateTemplate(sessionFactory);
    }

    public final SessionFactory getSessionFactory() {
        return (this.hibernateTemplate != null ? this.hibernateTemplate.getSessionFactory() : null);
    }

    public final void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    public final HibernateTemplate getHibernateTemplate() {
      return this.hibernateTemplate;
    }

    protected final void checkDaoConfig() {
        if (this.hibernateTemplate == null) {
            throw new IllegalArgumentException("'sessionFactory' or 'hibernateTemplate' is required");
        }
    }

    protected final Session getSession()
        throws DataAccessResourceFailureException, IllegalStateException {

        return getSession(this.hibernateTemplate.isAllowCreate());
    }

    protected final Session getSession(boolean allowCreate)
        throws DataAccessResourceFailureException, IllegalStateException {

        return (!allowCreate ?
            SessionFactoryUtils.getSession(getSessionFactory(), false) :
                SessionFactoryUtils.getSession(
                        getSessionFactory(),
                        this.hibernateTemplate.getEntityInterceptor(),
                        this.hibernateTemplate.getJdbcExceptionTranslator()));
    }

    protected final DataAccessException convertHibernateAccessException(HibernateException ex) {
        return this.hibernateTemplate.convertHibernateAccessException(ex);
    }

    protected final void releaseSession(Session session) {
        SessionFactoryUtils.releaseSession(session, getSessionFactory());
    }
}
复制代码

4.3.HibernateGenericDao.java

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

@SuppressWarnings("unchecked")
public class HibernateGenericDao extends HibernateDaoSupport {
    //空方法
}

4.4.GenericDaoImplHibernate

复制代码
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.springframework.util.Assert;
import ssh.core.dao.GenericDao;
import ssh.core.dao.support.HibernateGenericDao;

@SuppressWarnings("unchecked")
public class GenericDaoImplHibernate<T> extends HibernateGenericDao implements GenericDao<T>{

    protected Class<T> entityClass;
    
    public GenericDaoImplHibernate() {
        entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]; 
    }

    protected Class<T> getEntityClass() {
        return entityClass;
    }

    @Override
    public List<T> findAll(Class<T> entityClass) {
        return getHibernateTemplate().loadAll(entityClass);
    }

    public List<T> findAll(Class<T> entityClass, String orderBy,
            boolean isAsc) {
        Assert.hasText(orderBy);
        if (isAsc)
            return getHibernateTemplate().findByCriteria(
                    DetachedCriteria.forClass(entityClass).addOrder(Order.asc(orderBy)));
        else
            return getHibernateTemplate().findByCriteria(
                    DetachedCriteria.forClass(entityClass).addOrder(Order.desc(orderBy)));
    }
    
    @Override
    public List<T> findByExample(Object o) {
        return  getHibernateTemplate().findByExample(o);
    }
    
    @Override
    public T getById(Serializable id) {
        return (T)getHibernateTemplate().get(entityClass, id);
    }

    @Override
    public void deleteById(Serializable id) {
        delete(getById(id));
    }
    
    @Override
    public void delete(Object o) {
        getHibernateTemplate().delete(o);
    }
    
    @Override
    public void save(Object o) {
        getHibernateTemplate().save(o);
    }

    @Override
    public void saveOrUpdate(Object o) {
        getHibernateTemplate().saveOrUpdate(o);
    }

    @Override
    public void update(Object o) {
        getHibernateTemplate().update(o);
    }
}
复制代码

4.5.UserDao

import ssh.core.dao.GenericDao;
import ssh.pojo.User;

public interface UserDao extends GenericDao<User> {

}

4.6.UserDaoImpl

复制代码
import com.sjtu.erp.ssh.base.dao.UserDao;
import com.sjtu.erp.ssh.core.dao.impl.GenericDaoImplHibernate;
import com.sjtu.erp.ssh.pojo.User;

public class UserDaoImpl extends GenericDaoImplHibernate<User> implements UserDao {
    
}
分享到:
评论

相关推荐

    GenericDAO

    在Java中,DAO(Data Access Object)模式是用来封装对数据库的访问,将业务逻辑与数据访问逻辑分离,使系统更易于维护和扩展。GenericDAO通常会包含增删改查(CRUD)等基本操作,如`insert(T entity)`, `update(T ...

    Java反射泛型,实现数据库的动态增删改查等功能

    在数据库操作中,反射可以帮助我们根据字符串形式的SQL语句来动态执行相应的方法,无需预先编写大量硬编码的数据库访问代码。 例如,我们可以创建一个`DatabaseExecutor`类,它接受SQL语句作为输入,并通过反射调用...

    再发一个基于Hibernate+Spring 泛型GenericDao 的工程源码.

    在解压后,我们可以找到具体的`GenericDao.java`或相关的接口及实现类,通过阅读这些代码,可以深入理解如何在Spring和Hibernate环境中使用泛型来设计数据访问层。 总的来说,这个资源提供了一个使用泛型和主流Java...

    可以用来被继承的用Hibernate连接数据库的GenericDAO类(转)

    方便你使用的abstract类,继承起来非常方便

    数据库OrmLite

    在项目中使用ORMLite,首先需要添加对应的依赖库。对于Java项目,通常会使用Maven或Gradle来管理依赖,需要在配置文件中添加ORMLite的JAR包依赖。 2. **数据库配置** 在应用启动时,需要初始化ORMLite的配置,...

    Hibernate泛型DAO及使用方法

    首先,DAO(Data Access Object)模式是一种设计模式,它的主要作用是封装数据库访问的逻辑,使得业务层与数据访问层解耦。泛型DAO是DAO模式的一种改进,通过使用Java泛型,我们可以创建一个适用于任何类型的DAO接口...

    基于泛型与反射的万能数据库操作代码

    2. **访问和修改属性**:获取和设置实体对象的字段值,与数据库中的列进行映射。 3. **调用方法**:执行对象的方法,例如保存、更新或删除数据。 **创建万能Dao的步骤** 1. **定义泛型Dao接口**:创建一个泛型接口...

    基于hibernate的泛型Dao框架

    标题中的“基于Hibernate的泛型Dao框架”是指在Java开发中使用Hibernate ORM工具,并结合泛型设计模式构建的数据库访问对象(DAO)框架。这样的框架旨在提高代码复用性,减少重复工作,使得数据访问层的实现更加简洁...

    Hibernate泛型DAO及使用方法.doc

    总的来说,泛型DAO是Java开发中一个实用的设计模式,它结合了Hibernate的强大功能和泛型的灵活性,为开发人员提供了高效、可复用的数据库访问层。在Spring+Hibernate环境下,通过合理地实现和使用泛型DAO,可以大大...

    DAO模式设计

    DAO(Data Access Object)模式是软件开发中常用的设计模式,主要目的是为了将数据访问层与业务逻辑层解耦,提供一个抽象层来处理数据库操作。DAO模式的核心思想是通过创建一个独立于具体数据库操作的对象(即DAO)...

    ORMLite jar、文档、源码、以及博客实例

    在本资源包中,包含了ORMLite的核心jar文件,官方文档,源码以及一个基于CSDN博客的实例代码,旨在帮助开发者更好地理解和使用ORMLite。 **ORMLite核心概念** 1. **实体类(Entity Class)**:开发者定义的Java类,...

    dao.rar_dao

    在IT行业中,DAO(Data Access Object)模式是一种常见的软件设计模式,主要用于数据库访问层的抽象。DAO模式的主要目的是为了隔离应用程序与数据存储之间的交互,从而提高代码的可测试性、可维护性和解耦性。本资源...

    Java JDBC简单入门之枚举(Enum)、泛型、反射、JDBC整合

    泛型是Java SE 5.0引入的新特性,允许在类、接口和方法中使用类型参数,以增强代码的类型安全性和重用性。在JDBC操作中,我们可以使用泛型来创建通用的DAO(Data Access Object)类,如下所示: ```java public ...

    sample-java-spring-genericdao:使用 Spring MVC 4.1、Hibernate 4.3 + Generic DAO、Spring Security、Freemarker 的项目示例

    目标是展示一个使用 Spring 与 Hibernate 集成的安全 MVC 应用程序,并使用 Generic DAO 框架抽象 DAO 层。 跑前小贴士: 将项目作为现有 Maven 导入(由于父项,您必须两次更新项目) 数据库文件 (DemoDB.rar) ...

    MongoDB-GenericDao:MongoDB GenericDao 使用 Linq 支持管理 MongoCollections

    #MongoDB GenericDao ###C# 使用 MongoDB 驱动程序和 Linq 支持实现到 GenericDao 模式 ##支持哪些方法? T GetByID(ID id); IEnumerable GetAll(); T GetByCondition(System.Linq.Expressions.Expression&lt;Func&gt;&gt;...

    Android 使用ORMLite打造万能泛型Dao简化数据持久化层

    在Android中使用ORMLite,首先需要添加ORMLite库的依赖。在当前项目中,可以通过Gradle配置文件引入ORMLite的Android版本: ```groovy dependencies { implementation 'com.j256.ormlite:ormlite-android:5.1' } `...

    hibernate 通用接口架构

    DAO层作为业务逻辑和数据存储之间的中间层,它的主要职责是封装对数据库的操作,将数据库交互的细节隐藏起来,使得业务逻辑层无需关心具体的数据库操作,只需要调用DAO接口即可完成数据的增删改查。 在面向接口的...

    一个简单的Hibernate泛型Dao的实现 ---- 20160624

    在Java的持久层开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它能够将数据库的操作转化为对Java对象的操作,简化了数据库编程。本文将深入探讨如何实现一个简单的Hibernate泛型DAO(数据访问对象),...

    通用DAO

    在IT行业中,数据库操作是开发工作中的重要环节,而DAO(Data Access Object)模式则是用于封装数据访问逻辑的一种设计模式。通用DAO的概念旨在减少数据库操作的重复性工作,提高代码的可复用性和可维护性。本文将...

Global site tag (gtag.js) - Google Analytics