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);
    }

}

使用泛型可以使代码大大的精简