hibernate的工具类

获取Session类：

package com.dada.pager;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class Hibernate_Util {

	private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
	//为本地变量sessionThreadLocal创建一个副本
	private static final ThreadLocal<Session> sessionThreadLocal = new ThreadLocal<Session>();
	//为本地变量tranTreadLocal创建一个副本
	private static final ThreadLocal<Transaction> tranTreadLocal = new ThreadLocal<Transaction>();
	private  static Configuration configuration = new Configuration();    
	private static org.hibernate.SessionFactory sessionFactory;
	//生成日志对象
	private static final Log log = LogFactory.getLog(Hibernate_Util.class);

	//生成sessionFactory
	static {
		try {
			log.error("log is success！");
			configuration.configure(CONFIG_FILE_LOCATION);
			sessionFactory = configuration.buildSessionFactory();
		} catch (Exception e) {
			log.error("%%%% Error Creating SessionFactory %%%%");
			e.printStackTrace();
		}
	}

	private Hibernate_Util() {
	}

	/**
	 * 获取hibernate session
	 * @return Session
	 * @throws HibernateException
	 */
	public static Session getSession() throws HibernateException {
		Session session = (Session) sessionThreadLocal.get();

		if (session == null || !session.isOpen()) {
			if (sessionFactory == null) {
				rebuildSessionFactory();
			}
			session = (sessionFactory != null) ? sessionFactory.openSession()
					: null;
			log.info("Session 创建成功");
			sessionThreadLocal.set(session);
		}

		return session;
	}

	/**
	 *  重新生成sessionFactory
	 *
	 */
	public static void rebuildSessionFactory() {
		try {
			configuration.configure(CONFIG_FILE_LOCATION);
			sessionFactory = configuration.buildSessionFactory();
		} catch (Exception e) {
			log.error("%%%% Error Creating SessionFactory %%%%");
			e.printStackTrace();
		}
	}

	/**
	 *  关闭session
	 */
	public static void closeSession() throws HibernateException {
		Session session = (Session) sessionThreadLocal.get();
		try{
			if (session != null) {
				session.close();
				log.info("Session 关闭成功");
				sessionThreadLocal.set(null);
			}
		}catch(Exception e) {
			e.printStackTrace();
			log.error("Session关闭失败");
		}
	}

	/**
	 * 开始事务
	 */
	public static void beginTran() {
		Session session = getSession();
		try {
			if(session != null) {
				//开始事务
				Transaction tran = session.beginTransaction();
				log.info("事务开始成功！");//生成日志
				tranTreadLocal.set(tran);//存储日志
			}
		}catch(Exception e){
			log.error("事务开始失败！");
		}
	}

	/**
	 * 提交事务
	 */
	public static void commitTran() { 
		Transaction tran = tranTreadLocal.get();
		try{
			if(tran != null && !tran.wasCommitted()&&!tran.wasRolledBack()) {
				tran.commit();
				log.info("事务提交成功！");
				tranTreadLocal.set(null);
			}
		}catch(Exception e) {
			e.printStackTrace();
			log.info("事务提交失败！");
		}
	}

	/**
	 * 回滚事务
	 */
	public static void rollbackTran() {
		Transaction tran = tranTreadLocal.get();
		try {
			if(tran != null && !tran.wasCommitted()&&!tran.wasRolledBack()) {
				tran.rollback();
				log.info("事务回滚成功！");
				tranTreadLocal.set(null);
			}
		} catch(Exception e) {
			e.printStackTrace();
			log.error("事务回滚失败！");
		}
	}

	/**
	 * 获取SessionFactory
	 *  return session factory
	 */
	public static org.hibernate.SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	/**
	 * 设置hibernate.cfg.xml位置
	 * @param configFile
	 */
	public static void setConfigFile(String configFile) {
		Hibernate_Util.CONFIG_FILE_LOCATION = configFile;
		sessionFactory = null;
	}

	/**
	 * 获取Configuration
	 *  return hibernate configuration
	 */
	public static Configuration getConfiguration() {
		return configuration;
	}

}

对象的CRUD操作类：

package com.dada.pager;

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

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;

import com.sun.org.apache.commons.beanutils.BeanUtils;

public class Hibernate_Template {

	public Hibernate_Template() {
		super();
	}

	/**
	 * 获取Session
	 * @return
	 */
	public Session getSession() {
		return Hibernate_Util.getSession();
	}
	
	/**
	 * 关闭Session
	 */
	public void closeSession() {
		Hibernate_Util.closeSession();
	}
	
	/**
	 * 开启Session
	 */
	public void beginTran() {
		Hibernate_Util.beginTran();
	}
	
	/**
	 * 提交事务
	 */
	public void commitTran() {
		Hibernate_Util.commitTran();
	}
	
	/**
	 * 回滚事务 
	 */
	public void rollbackTran() {
		Hibernate_Util.rollbackTran();
	}
	
	/**
	 * 得到一个对象
	 * @return
	 */
	public Object get(Class pocalss,Serializable id) {
		return this.getSession().get(pocalss, id);
	}
	
	/**
	 * 得到一个对象
	 * @param pocalss
	 * @param id
	 * @return
	 */
	public Object load(Class pocalss,Serializable id) {
		return this.getSession().load(pocalss, id);
	}
	
	/**
	 * 通过hql语句和参数来获取对象
	 * @param hql
	 * @param params
	 * @return
	 */
	public Object get(String hql,Object...params) {
		Query query = this.getSession().createQuery(hql);
		this.setParameter(query, params);
		return query.uniqueResult();
	}
	
	/**
	 * 获取对象的总的个数
	 * @param hql
	 * @param params
	 * @return
	 */
	public Integer count(String hql,Object...params) {
		Object obj = this.get(hql, params);
		long count= (Long)obj;  
		return new Integer((int)count);
	}
	
	public List getObjects(String hql,Object...params) {
		Query query = this.getSession().createQuery(hql);
		this.setParameter(query, params);
		return query.list();
	}
	
	/**
	 * 查询指定页的记录
	 * @param hql
	 * @param curpage
	 * @param pagerecord
	 * @param params
	 * @return
	 */
	public List getObjects(String hql,int curpage,int pagerecord,Object...params) {
		Query query = this.getSession().createQuery(hql);
		this.setParameter(query, params);
		query.setFirstResult((curpage-1)*pagerecord);
		query.setMaxResults(pagerecord);
		return query.list();
	}
	
	/**
	 * 获取查询出来的结果的复制对象
	 * @param hql
	 * @param curpage
	 * @param pagerecord
	 * @param voclass
	 * @param params
	 * @return
	 */
	public List getObjects(String hql,int curpage,int pagerecord,Class voclass,Object...params) {
		List vos = new ArrayList();
		try{
			Query query = this.getSession().createQuery(hql);
			this.setParameter(query, params);
			query.setFirstResult((curpage-1)*pagerecord);
			query.setMaxResults(pagerecord);
			List<Object[]> list = query.list();
			for (Object[] objs : list) {
				Object vo = voclass.newInstance();
				for (Object object : objs) {
					BeanUtils.copyProperties(vo, object);
				}
				vos.add(vo);
			}
			
		}catch(Exception e) {
			e.printStackTrace();
		}
		return vos;
	}
	
	public List getObjects(DetachedCriteria c,int curpage,int pagerecord,Criterion...params) {
		if(params != null && params.length>0) {
			for(Criterion cond:params) {
				c.add(cond);
			}
		}
		Criteria criteria = c.getExecutableCriteria(this.getSession());
		criteria.setFirstResult((curpage-1)*pagerecord);
		criteria.setMaxResults(pagerecord);
		criteria.setResultTransformer(criteria.DISTINCT_ROOT_ENTITY);
		return criteria.list();
	}
	
	public Integer countByDetached(DetachedCriteria c,Criterion...params) {
		if(params!=null && params.length>0) {
			for(Criterion cond:params) {
				c.add(cond);
			}
		}
		//传递一个Session由DetachedCriteria可执行查询的Criteria
		Criteria criteria = c.getExecutableCriteria(this.getSession());
		criteria.setResultTransformer(criteria.DISTINCT_ROOT_ENTITY);
		criteria.setProjection(Projections.rowCount());
		return (Integer) criteria.uniqueResult();
	}
	
	/**
	 * 无参数删除
	 * @param pocalss
	 * @param id
	 */
	public void delete(Class pocalss,Serializable id) {
		try{
			Object obj = this.getSession().get(pocalss, id);
			this.getSession().delete(obj);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 有参数删除
	 * @param po
	 */
	public void delete(Object po) {
		try {
			this.getSession().delete(po);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 有参数删除
	 * @param hql
	 */
	public void delete(String hql) {
		try {
			Query query = this.getSession().createQuery(hql);
			query.executeUpdate();
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 删除对象
	 * @param obj
	 */
	public void update(Object obj) {
		try{
			this.getSession().update(obj);
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
	/**
	 * 修改对象
	 * @param hql
	 * @param params
	 */
	public void update(String hql,Object...params) {
		try{
			Query query = this.getSession().createQuery(hql);
			this.setParameter(query, params);
			query.executeUpdate();
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 合并对象
	 * @param po
	 */
	public void merge(Object po) {
		try{
			this.getSession().merge(po);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 保存对象
	 * @param po
	 * @return
	 * @throws Exception 
	 */
	public Serializable save(Object po) throws Exception {
		try{
			return this.getSession().save(po);
		}catch(Exception e) {
			e.printStackTrace();
			throw e;
		}
	}
	
	/**
	 * 保存或者修改对象
	 * @param obj
	 */
	public void saveOrUpdate(Object obj) {
		try {
			this.getSession().saveOrUpdate(obj);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 持久化对象
	 * @param po
	 */
	public void persist(Object po) {
		try{
			this.getSession().persist(po);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 按照顺序把参数设置到查询语句中
	 * @param query
	 * @param params
	 */
	public void setParameter(Query query,Object...params) {
		if(params!=null && params.length>0) {
			for (int i = 0; i < params.length; i++) {
				query.setString(i, params[i].toString());
			}
		}
	}
}