DAO层使用泛型的两种方式

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

}