數據庫訪問層中使用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 {
    
}