个人用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();
}

}

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