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);
}
}
使用泛型可以使代码大大的精简