个人用hibernate写的通用Dao

import java.io.Serializable;
import java.util.List;

import com.ssh.common.Order;

//使用泛型,重用性更高
public interface IBaseDao<T>{
	
	//保存对象
	Serializable save(T t);
	
	void saveOrUpdate(T t);
	
	//删,根据对象
	void delete(T t);
	//删,根据多个
	void deleteAll(List<T> t);
	//删,通过id删除
	void deleteById(Integer id);
	//删,通过屬性删除
	void deleteByPropertie(String name, String value);
	
	//改
	void update(T t);
	//改
	void update(List<T> list);
	
	//查询全部
	List<T> queryAll();
	//查,通过名字获取对象
	List<T> querybyProperties(String name, String value);
		
	List<T> querybyProperties(String name, List<String> values);
	
	List<T> querybyProperties(List<String> names, List<Object> values);
	
	List<T> querybyProperties(List<String> names, List<Object> values, String orderBy, Order order);
	
	//查,通过id获取对象
	T queryById(Integer id);
	
	//查,通过名字获取对象
	T queryUnique(String name, String value);

}

<pre name="code" class="java">import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public abstract class BaseDaoImpl<T> extends HibernateDaoSupport implements IBaseDao<T>{

	//注入获取sessionFactory
	@Autowired
	private void setMySessionFactory(SessionFactory sessionFactory){
	  //这个方法名可以随便写，@Resource可以通过name 或者type来装载的。
	  super.setSessionFactory(sessionFactory);
	 }
	
	private Class<T> clazz;
	
    @SuppressWarnings("unchecked")
	public BaseDaoImpl(){
        //使用反射技术得到T的真实类型
        //获取当前new的对象的泛型的父类
        ParameterizedType pt =(ParameterizedType) this.getClass().getGenericSuperclass();
        //获取第一个类型参数的真实类型
        this.clazz = (Class<T>) pt.getActualTypeArguments()[0];
     }
	
	public Serializable save(T t) {
		return getHibernateTemplate().save(t);
	}

	public void delete(T t) {
		
		 getHibernateTemplate().delete(t);
	}

	public void deleteById(Integer id) {
		
		T t=queryById(id);
		getHibernateTemplate().delete(t);
	}

	public void update(T t) {
		getHibernateTemplate().update(t);
	}

	@SuppressWarnings("unchecked")
	public List<T> queryAll() {
		
		//泛型from 类名(clazz.getSimpleName())
		return (List<T>) getHibernateTemplate().find("from "+clazz.getSimpleName());
	}

	public T queryById(Integer id) {
		return getHibernateTemplate().get(clazz, id);
	}

	public T queryUnique(String name, String value){
		Criteria criteria = getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(clazz).add(Restrictions.eq(name, value));
		return (T) criteria.uniqueResult();
	}

	public void deleteAll(List<T> t) {
		getHibernateTemplate().deleteAll(t);
	}

	public void deleteByPropertie(String name, String value) {
		T t=queryUnique(name, value);
		getHibernateTemplate().delete(t);
	}

	public void update(List<T> list) {
		for (T t : list) {
			getHibernateTemplate().update(t);
		}
	}

	
	//sessionFactory中创建一个绑定线程的session。Spring会根据该线程的执行情况来自动判断是关闭session还是延迟关闭,可避免手动的管理实务，
	//同时一个线程最多开启和关闭一次session又可以提高程序的性能
	
	//根据属性查询
	public List<T> querybyProperties(String name, List<String> values) {
		Criteria criteria=getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(clazz).add(Restrictions.in(name, values));
		//尽管这种方式拿到的Session会自动关闭，但是他是有一定的失效策略的，而且在超session池连接数的时候，spring无法自动的关闭这些session
		//Criteria criteria = getSession().createCriteria(clazz).add(Restrictions.in(name, values));
		return criteria.list();
	}

	//根据属性查询,不需要进行排序将排序字段和排序方式赋空 
	public List<T> querybyProperties(List<String> names, List<Object> values) {
		return querybyProperties(names, values, null, null);
	}

	
	/* names是字段名
	 * values是相应的条件
	 * orderBy排序的字段
	 * order 排序方式
	 */ 
	public List<T> querybyProperties(List<String> names, List<Object> values,
			String orderBy, com.ssh.common.Order order) {
		
		//先创建一个criteria对象
		Criteria criteria=getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(clazz);
		
		//对values进行遍历
		if (values != null) {
			for (int i = 0; i < values.size(); i++) {
				
				//拿到当前的value
				Object value = values.get(i);
				if (value instanceof Collection) {
					//当前字段(name)对应当前的value,进行查询,此时value为一个集合
					criteria.add(Restrictions.in(names.get(i), (Collection<?>) value));
				}
				else if (value instanceof Object[]) {
					//当前value为一个数组
					criteria.add(Restrictions.in(names.get(i), (Object[]) value));
				}
				else {
					//当前value就是单一个value
					criteria.add(Restrictions.eq(names.get(i), value));
				}
			}
		}
		//使用自定义枚举,这里对order字段进行判断,若空则不进行排序,否则判断是升序还是降序
		if(order!=null&&order==com.ssh.common.Order.desc){
			 criteria.addOrder(Order.desc(orderBy)); 
		}
		if(order!=null&&order==com.ssh.common.Order.asc){
			 criteria.addOrder(Order.asc(orderBy)); 
		}
		return criteria.list();
	}
	
	//会自定选定save或者update操作
	public void saveOrUpdate(T t) {
		getHibernateTemplate().saveOrUpdate(t);
	}
	
	//通过属性查询,返回一个list
	public List<T> querybyProperties(String name, String value) {
		Criteria criteria=getSessionFactory().getCurrentSession().createCriteria(clazz).add(Restrictions.eq(name, value));
		return criteria.list();
	}

}

下面是在别人博文上看到的通用DAO，也顺便记下来，供下次需要时使用：

package spring.demo.dao;

import java.io.Serializable;
import java.util.List;

public interface IGeneralDao {
	
	public <T> T findById(Class<T> type, Serializable id);    
    
    public <T> List<T> findAll(Class<T> type);    
    
    public void save(Object... entities);    
    
    public void update(Object... entities);    
    
    public void saveOrUpdate(Object entity);    
    
    public void delete(Object... entities);    
    
    public void deleteById(Class<?> type, Serializable id);    
    
    public void refresh(Object... entities);    
    
    public void flush();  
}

package spring.demo.dao.impl;

import java.io.Serializable;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateTemplate;

import spring.demo.dao.IGeneralDao;

public abstract class GeneraDao implements IGeneralDao{
	
	@Autowired
	private HibernateTemplate hibernateTemplate;

	public <T> T findById(Class<T> type, Serializable id) {
		
		return hibernateTemplate.get(type, id);
	}

	public <T> List<T> findAll(Class<T> type) {
		
		return hibernateTemplate.loadAll(type);
	}

	public void save(Object... entities) {
		for (Object entity: entities) {
			hibernateTemplate.save(entity);
		}
			
	}

	public void update(Object... entities) {
		for (Object entity : entities) {
			hibernateTemplate.update(entity);
		}
	}

	public void saveOrUpdate(Object entity) {
		hibernateTemplate.saveOrUpdate(entity);
	}

	public void delete(Object... entities) {
		for (Object entity : entities) {
			if(entity!=null){
				hibernateTemplate.delete(entity);
			}
		}
	}

	public void deleteById(Class<?> type, Serializable id) {
		if(id==null)
			return;
		Object entity=findById(type, id);
		if(entity==null)
			return;
		delete(entity);
	}

	public void refresh(Object... entities) {
		for (Object entity : entities) {
			hibernateTemplate.refresh(entity);
		}
	}

	public void flush() {
		hibernateTemplate.flush();
	}

}

后续还会进一步优化和改进,如有建议和错误,欢迎广大网友指出