自己写的一个Hibernate CURD的封装

自己在dome一个小项目的时候,突发奇想,利用单例和工厂加上泛型的知识封装Po的CURD操作,直接上代码,文笔不好,呵呵，还请大家指教

接口规范，定义CURD操作

package edu.sasu.DAO;

import java.util.List;


/**
 * 所有实体类遵循的接口
 * @author Administrator
 *
 * @param <T>
 * @param <ID>
 */
public interface BaseDao<T> {

	/**
	 * 保存实体
	 * @param entity 实体类
	 */
	public boolean save(T entity);
	
	/**
	 * 删除实体
	 * @param entity 实体类
	 */
	public boolean delete(T entity);
	
	/**
	 * 根据实体ID删除实体
	 * @param entity 实体类
	 */
	public boolean deleteById(T entity);
	
	/**
	 * 跟新实体
	 * @param entity 实体类
	 */
	//public boolean update(T entity);
	public boolean update(T entity, Object OID);
	/**
	 * 根据实体d,查询单个实体
	 * @param entity 实体类 
	 * @return
	 */
	//public T findById(T entity);
	public T findById(T entity, Object entityID);
	/**
	 * 累出所有实体集合
	 * @param entityClass 实体类
	 * @return 实体类List
	 */
	public  List<T> findAll(String hql);
	
	public List<T> findAll(T entity);
	
	/**
	 * 保存和跟新方法
	 */
	public boolean saveOrUpdate(T entity);
}

实现BaseDao接口,实现其中的方法

package edu.sasu.DAOImpl;

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

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import edu.sasu.DAO.BaseDao;
import edu.sasu.Util.DBUtil;
/**
 * 封装的基类操作
 * @author Administrator
 *
 * @param <T>
 */
public class BaseDAOImpl<T>  implements BaseDao<T>{
	public synchronized boolean delete(T entity) {
		// TODO Auto-generated method stub
		return false;
	}
    /**
     * 删除某条数据
     */
	public synchronized boolean deleteById(T entity) {
		Session session = DBUtil.getDBUtil().getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			session.delete(entity);
			tx.commit();
		} catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			return false;
		}
		return true;
	}

	public synchronized List<T> findAll(T entity) {
		// TODO Auto-generated method stub
		return null;
	}
    /**
     * 查找单个数据
     */
	public synchronized T findById(T entity, Object entityID) {
		Session session = DBUtil.getDBUtil().getSession();
		Transaction tx = null;
		T temp;
		try {
			tx = session.beginTransaction();
			temp = (T) session.get(entity.getClass(),(Serializable) entityID);
			tx.commit();
		} catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			throw e;
		}finally{
			
		}
		return temp;
	}
    /**
     * 保存数据
     */
	public synchronized boolean save(T entity) {
		Session session = DBUtil.getDBUtil().getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			//session.persist(entity);
			session.save(entity);
			tx.commit();
		} catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			//return false;
			e.printStackTrace();
		}
		return true;
	}
    /**
     * 跟新数据
     */
	public synchronized boolean update(T entity, Object OID) {
		Session session = DBUtil.getDBUtil().getSession();
		Transaction tx = null;
		
		try {
			tx = session.beginTransaction();	
			T temp = (T) session.get(entity.getClass(), (Serializable) OID);
			session.merge(entity); //如果update要抛异常
			tx.commit();
		} catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			//return false;
			e.printStackTrace();
		}
		return true;
	}
    /**
     * 查找符合hql的所有数据
     */
	public synchronized List<T> findAll(String hql) {
		Session session = DBUtil.getDBUtil().getSession();
		Transaction tx = null;
		List<T> list = new ArrayList<T>();
		try {
			tx = session.beginTransaction();
			list = session.createQuery(hql).list();
			session.flush();
			tx.commit();
		} catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			e.printStackTrace();
		}
		return list;
	}
	
	/**
	 * 保存和跟新方法
	 */
	public synchronized boolean saveOrUpdate(T entity) {
		Session session = DBUtil.getDBUtil().getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			session.saveOrUpdate(entity);
			tx.commit();
		} catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			//return false;
			e.printStackTrace();
		}
		return true;
	}
}

基础工厂采用单例实现获取实例操作对象

package edu.sasu.factory;

import edu.sasu.DAO.BaseDao;
import edu.sasu.DAOImpl.BaseDAOImpl;
/**
 * 基础工厂
 * @author Administrator
 *
 * @param <T>
 */
public class BaseFactory<T> {
	
	private static BaseFactory baseFactory; //单一实例
	private BaseDao<T> Instance;
	private BaseFactory(){
		Instance = new BaseDAOImpl<T>();	
	}
	
	public BaseDao<T> getInstance(){ //不要把factory的new放在构造函数里面,不然会出现递归错误
		return Instance;
	}
	
	public static BaseFactory getFactory(){
		if(baseFactory == null){
			baseFactory = new BaseFactory();
		}
		return baseFactory;
	}
}

以上定义baseDAO接口,baeDAOIMpl是接口的实现,baseFactory是工厂,对baseDAOimp实例化,
在类中调用为: User(一个PoJo类)
User entity= new User();
BaseFactory<User> factory = BaseFactory.getFactory();
执行保存操作: factory.getInstance().save(entity);  entity User的实例对象
执行保存操作,请大家评点下此种写法有什么不好的地方,本人能力有限,觉得还可以,请大牛指教

一个业务需要多个操作你的事务怎么处理呢？

事务常规上是应该切一下的，这里代码里声明事务并提交会导致楼上说的问题哦。

多个操作,可能在封装几个方法,呵呵，这个有局限性,楼上可有好方法解决

现在惯用的方法是在spring做个切面，把整个事务用切面管理，dao完全不搭理事务的问题。
例如 一个service调用多个dao方法，那么切面应该切在service方法的前后，在进入service方法之前由transcationmanager声明事务（现成的，配置好就是自动的了），进入dao时从dbutil中获取的应该是绑定在sessionholder中的session，进而保证了多个dao方法用的是相同的session从而保证事务；而在service方法结束时，也由transcationmanager将事务提交。（发现异常回滚）


貌似是这么回事。之前翻的是jdbc那部分的源码，hibernate的也看过一点，应该是一样的，就是一个hold的是connection一个hold的是session.另外，可能要注意处理session关闭的问题，看看是否需要用dbutil去关闭session

你为什么要在你的每个方法上做同步控制呢？它们有访问共享资源吗？

+1

犀利。。。。

+1

我感觉GenericDao这种东西的数量快要赶上IT从业人员了