DAO層使用泛型的兩種方式

1.DAO層使用泛型類，主要是定義一些通用的增刪改查，然后其他DAO的類都來繼承該類，通過構造方法將class對象傳給該泛型類

定義泛型接口

package sanitation.dao;

import java.util.List;
/**
 *
 * @param <T>
 */

public interface GenericDAO <T>{
    /**
     * 通過ID獲得實體對象
     * 
     * @param id實體對象的標識符
     * @return 該主鍵值對應的實體對象
     */
    T findById(int id);
    
    /**
     * 將實體對象持久化
     * 
     * @param entity 需要進行持久化操作的實體對象
     * @return 持久化的實體對象
     */
    T makePersitent(T entity); 
    
    /**
     * 將實體變為瞬態
     * 
     * @param entity需要轉變為瞬態的實體對象
     */
    void makeTransient(T entity);
    
    /**
     * 將一系列的實體變為瞬態，使用本地sql
     * 
     * @param hql
     */
    void makeTransientByIds(String sql);
    
    /**
     * 
     * 使用hql語句進行分頁操作
     * 
     * @param hql    
     * @param offset    第一條記錄索引
     * @param pageSize    每頁需要顯示的記錄數
     * @return    查詢的記錄
     */
    List<T> findByPage(final String hql,final int offset,final int pageSize);
    
    
    /**
     * 使用hql 語句進行分頁查詢操作
     * 
     * @param hql 需要查詢的hql語句
     * @param value 如果hql有一個參數需要傳入，value就是傳入的參數
     * @param offset 第一條記錄索引
     * @param pageSize 每頁需要顯示的記錄數
     * @return 當前頁的所有記錄
     */
    List<T> findByPage(final String hql , final Object value ,
             final int offset, final int pageSize);
    
    /**
     * 使用hql 語句進行分頁查詢操作
     * 
     * @param hql 需要查詢的hql語句
     * @param values 如果hql有一個參數需要傳入，value就是傳入的參數
     * @param offset 第一條記錄索引
     * @param pageSize 每頁需要顯示的記錄數
     * @return 當前頁的所有記錄
     */
    List<T> findByPage(final String hql, final Object[] values,
             final int offset, final int pageSize);
    

    /**
     * 使用sql 語句進行分頁查詢操作
     * 
     * @param sql
     * @param offset
     * @param pageSize
     * @return
     */
    List findByPageSQL(final String sql, 
             final int offset, final int pageSize);
    
    /**
     * 根據語句查找總數
     * @param hql hql語句
     * @return 對應的數目
     */
    Integer getCount(String hql);
    
    
    void updateObj(final String hql,final Object[] values);
}

定義實現類

package sanitation.dao.impl;

import java.sql.SQLException;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import sanitation.dao.GenericDAO;

public class GenericHibernateDAO<T> extends HibernateDaoSupport 
    implements GenericDAO<T>{

    private Class<T> persistentClass;
    
    public GenericHibernateDAO(Class<T> persistentClass){
        this.persistentClass=persistentClass;
    }
    
    public Class<T> getPersistentClass(){
        return persistentClass;
    }
    
    @SuppressWarnings("unchecked")
    public T findById(int id) {
        return (T)getHibernateTemplate().get(getPersistentClass(), id);
    }

    @SuppressWarnings("unchecked")
    public List<T> findByPage(final String hql, 
         final int offset, final int pageSize){
        List<T> list= getHibernateTemplate().executeFind(new HibernateCallback(){
                public Object doInHibernate(final Session session)
                    throws HibernateException, SQLException{
                    Query query=session.createQuery(hql);
                    if(!(offset==0 && pageSize==0)){
                        query.setFirstResult(offset).setMaxResults(pageSize);
                    }
                    List<T> result = query.list();
                    return result;
                }
            });
        return list;
    }
    
    @SuppressWarnings("unchecked")
    public List findByPageSQL(final String sql, 
         final int offset, final int pageSize){
        List list= getHibernateTemplate().executeFind(new HibernateCallback(){
                public Object doInHibernate(final Session session)
                    throws HibernateException, SQLException{
                    Query query=session.createSQLQuery(sql);
                    if(!(offset==0 && pageSize==0)){
                        query.setFirstResult(offset).setMaxResults(pageSize);
                    }
                    List result = query.list();
                    return result;
                }
            });
        return list;
    }
    

    @SuppressWarnings("unchecked")
    public List<T> findByPage(final String hql, final Object value, 
            final int offset, final int pageSize) {
        List<T> list = getHibernateTemplate().executeFind(new HibernateCallback()
        {
            public Object doInHibernate(Session session)
                throws HibernateException, SQLException
            {
                Query query=session.createQuery(hql).setParameter(0, value);
                if(!(offset==0 && pageSize==0)){
                    query.setFirstResult(offset).setMaxResults(pageSize);
                }
                List<T> result = query.list();
                return result;
            }
        });
        return list;
    }

    @SuppressWarnings("unchecked")
    public List<T> findByPage(final String hql, final Object[] values, final int offset,
            final int pageSize) {
        List<T> list = getHibernateTemplate().executeFind(new HibernateCallback(){
            public Object doInHibernate(Session session)
                throws HibernateException, SQLException{
                Query query=session.createQuery(hql);
                for (int i = 0 ; i < values.length ; i++){
                    query.setParameter( i, values[i]);
                }
                if(!(offset==0 && pageSize==0)){
                    query.setFirstResult(offset).setMaxResults(pageSize);
                }
                List<T> result = query.list();
                return result;
            }
        });
    return list;
    }
    

    public void updateObj(final String hql, final Object[] values) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session)
            throws HibernateException, SQLException{
                Query query=session.createQuery(hql);
                for(int i=0;i<values.length;i++){
                    query.setParameter( i, values[i]);
                }
                query.executeUpdate();
                return null;    
            }
        });
    }

    public Integer getCount(String hql) {
        Integer count;
        //iterate方法與list方法的區別是list取出全部，iterator取出主鍵，迭代的時候才取出數據
        count = ((Long)getHibernateTemplate().iterate(hql).next()).intValue();
        return count;
    }

    public T makePersitent(T entity) {
        getHibernateTemplate().saveOrUpdate(entity);
        return entity;
    }

    public void makeTransient(T entity) {
        getHibernateTemplate().delete(entity);
    }

    public void makeTransientByIds(final String sql) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session)
            throws HibernateException, SQLException{
                Query query=session.createQuery(sql);
                query.executeUpdate();
                return null;
            }
        });
    }

}

2.而有時我們為了方便起見，對於一些簡單的項目，DAO的操作很單一，不會有很復雜的操作，那么我們直接用泛型方法類代替泛型類，主要就不需要寫其他的DAO來繼承，

整個DAO層就一個DAO類。

接口：

package com.xidian.dao;

import java.util.List;

import com.xidian.bean.Admin;
import com.xidian.bean.HostIntroduce;
import com.xidian.bean.Reply;

public interface CommonDAO {
    public <T> void sava(T entity);                                        //保存用戶，無返回值；
    public <T> void remove(T entity);                                    //刪除用戶
    public <T> void update(T entity);                                    //更新用戶
    public <T> T findById(Class<T> entityClass, Integer id);            //通過id來查找某一個用戶；
    public <T> List<T> findAll(Class<T> entityclass);                    //使用范型List<>，查詢所有的用戶信息

}

實現類：

package com.xidian.dao.impl;

import java.util.List;

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

import com.xidian.bean.Admin;
import com.xidian.bean.HostIntroduce;
import com.xidian.bean.Reply;
import com.xidian.dao.CommonDAO;

public class CommonDAOImpl extends HibernateDaoSupport implements CommonDAO {
    @SuppressWarnings("unchecked")
    @Override
    public <T> List<T> findAll(Class<T> entityclass) {
        //String name = entity.getClass().getName();
        String hql = "from "+entityclass.getName()+" as aaa order by aaa.id desc";
        return this.getHibernateTemplate().find(hql);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T findById(Class<T> entityClass, Integer id) {
        return (T) this.getHibernateTemplate().get(entityClass, id);
    }

    @Override
    public <T> void remove(T entity) {
        this.getHibernateTemplate().delete(entity);
    }

    @Override
    public <T> void sava(T entity) {
        this.getHibernateTemplate().save(entity);
    }

    @Override
    public <T> void update(T entity) {
        this.getHibernateTemplate().update(entity);
    }

}

使用泛型可以使代碼大大的精簡