hibernate工具类

package com.chinasofti.articlesys.util;

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

import javax.annotation.Resource;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.stereotype.Component;

/**
 * @author Administrator
 *Hibernate操作工具类
 */
@Component
public class HibernateUtil {
	@Resource(name="sessionFactory")
	private SessionFactory factory;
	
	/**
	 * @return获取会话工厂对象
	 */
	public SessionFactory getFactory(){
		return factory;
	}
	
	/**
	 * 应用于使用事务处理的数据更新操作会话
	 * @return返回会话连接对象
	 */
	public Session getCurSession(){
		
		try {
			return factory.getCurrentSession();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * 应用于不使用事务处理的查询操作会话
	 * @return
	 */
	public Session openSession(){
		try {
			return factory.openSession();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * @param obj
	 * @return添加数据的方法
	 */
	public Serializable add(Object obj){
		Session session = getCurSession();
		//执行添加操作
		return session.save(obj);
	}
	/**
	 * @param obj
	 * @return修改数据的方法
	 */
	public boolean update(Object obj){
		boolean resu=true;
		Session session = getCurSession();
		//执行添加操作
		session.update(obj);
		return resu;
	}
	/**
	 * @param obj
	 * @return删除数据
	 */
	public boolean delete(Object obj){
		boolean resu=true;
		Session session = getCurSession();
		//执行添加操作
		session.delete(obj);
		return resu;
	}
	/**
	 * 删除持久化对象
	 * @param cla
	 * @param id
	 * @return
	 */
	public boolean del(Class cla,int id){
		Session session=getCurSession();
		//先根据主键查询
		Object obj=session.get(cla, id);
		//再删除数据
		session.delete(obj);
		return true;
	}
	
	public <T> T get(Class cla,int id){
		T obj=null;
		Session session = getCurSession();
		//执行添加操作
		obj=(T)session.get(cla, id);
		return obj;
	}
	
	/**
	 * @param <T>集合泛型
	 * @param hql语句
	 * @param isCach参数是否缓存数据，真为缓存，假不缓存
	 * @param pras参数
	 * @return使用HQL查询返回一条及以上数据
	 */
	public <T> List<T> queryHQL(String hql,Boolean isCach,Object...pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			Query query = session.createQuery(hql);
			//设置是否需要将数据保存到缓存中
			query.setCacheable(isCach);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			list = query.list();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	/**
	 * @param <T>
	 * @param hql
	 * @param page
	 * @param size
	 * @param pras
	 * @return分页获取数据
	 */
	public <T> List<T> queryHQLByPage(String hql,int page,int size,Object...pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			Query query = session.createQuery(hql);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			//开始记录的行数
			query.setFirstResult((page-1)*size);
			//每页获取的记录数
			query.setMaxResults(size);
			list = query.list();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	
	/**
	 * @param <T>
	 * @param hql
	 * @param pras根据参数使用HQL查询返回单条数据
	 */
	public <T> T queryUnique(String hql,Object...pras){
		T obj=null;
		Session session=openSession();
		try {			
			Query query = session.createQuery(hql);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			//返回单条数据
			obj=(T)query.uniqueResult();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return obj;
	}
	
	/**
	 * @param hql
	 * @param pras
	 * @return查询返回数据记录个数
	 */
	public Long getCount(String hql,Object...pras){
		Long count=Long.valueOf("0");
		Session session=openSession();
		try {			
			Query query = session.createQuery(hql);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			//返回一行一列的数据
			//count=(Long)query.list().iterator().next();
			count=(Long)query.list().get(0);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return count;
	}
	
	/**
	 * @param <T>
	 * @param dc
	 * @return应用于离线组合条件查询
	 */
	public <T> List<T> queryByDetached(DetachedCriteria dc){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			Criteria c=dc.getExecutableCriteria(session);
			list=c.list();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	
	/**
	 * @param <T>
	 * @param cla
	 * @param sql
	 * @param pras
	 * @return使用SQL查询数据
	 */
	public <T> List<T> queryBySQL(Class cla, String sql,Object...pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			SQLQuery query= session.createSQLQuery(sql);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			list=query.addEntity(cla).list();			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	
	
	
	public <T> List<T> queryBySQLForPage(Class cla, String sql,int page,int size,Object...pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			SQLQuery query= session.createSQLQuery(sql);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			//开始记录的行数
			query.setFirstResult((page-1)*size);
			//每页获取的记录数
			query.setMaxResults(size);
			list=query.addEntity(cla).list();			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	/**
	 * @param <T>
	 * @param named
	 * @param isCach
	 * @param pras
	 * @return根据命名方式查询数据
	 */
	public <T> List<T> queryNamedQuery(String named,Boolean isCach,Object...pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			Query query = session.getNamedQuery(named);
			//设置是否需要将数据保存到缓存中
			query.setCacheable(isCach);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			list = query.list();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	/**
	 * @param <T>
	 * @param named
	 * @param page
	 * @param size
	 * @param pras
	 * @return根据命名方式查询数据，分页获取
	 */
	public <T> List<T> queryNamedQueryByPage(String named,int page,int size,Object...pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			Query query = session.getNamedQuery(named);
			//判断是否有参数
			if (pras != null) {
				for (int i = 0; i < pras.length; i++) {
					query.setString(i, pras[i].toString());
				}
			}
			//开始记录的行数
			query.setFirstResult((page-1)*size);
			//每页获取的记录数
			query.setMaxResults(size);
			list = query.list();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	/**
	 * @param <T>
	 * @param named
	 * @param isCach
	 * @param pras
	 * @return根据命名方式查询，使用MAP传参数
	 */
	public <T> List<T> queryNamedQuery(String named,Boolean isCach,Map<String,Object> pras){
		List<T> list=new ArrayList<T>();
		Session session=openSession();
		try {			
			Query query = session.getNamedQuery(named);
			//设置是否需要将数据保存到缓存中
			query.setCacheable(isCach);
			//判断是否有参数
			if (pras != null) {
				for (String key : pras.keySet()) {
					query.setString(key, pras.get(key).toString());
				}
			}
			list = query.list();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(session!=null)
				session.close();
		}
		return list;
	}
	
	
public <T> List<T> listByCQ(Class<?> cla,List<Criterion> cqs){
		
		List<T> list = new ArrayList<T>();
		Session session = openSession();
		
		Criteria ca=session.createCriteria(cla);
		if(cqs.size()>0){
			for(Criterion cq:cqs){
				ca.add(cq);
			}
		}
		
		list=ca.list();
		session.close();
		
		return list;
	}
	
	public <T> List<T> listByCQ(Class<?> cla,List<Criterion> cqs,int page,int size){
		
		List<T> list = new ArrayList<T>();
		Session session = openSession();
		
		
		Criteria ca=session.createCriteria(cla);
		if(cqs.size()>0){
			for(Criterion cq:cqs){
				ca.add(cq);
			}
		}
		ca.setFirstResult((page-1)*size);
		ca.setMaxResults(size);
		
		list=ca.list();
		session.close();
		
		return list;
	}
	
	public Long countlistByCQ(Class<?> cla,List<Criterion> cqs){
		
		Long count=Long.valueOf("0");
		Session session = openSession();
		
		
		Criteria ca=session.createCriteria(cla);
		if(cqs.size()>0){
			for(Criterion cq:cqs){
				ca.add(cq);
			}
		}
		
		count=(Long) ca.list().get(0);
		session.close();
		
		return count;
	}
	
	
	
	
	public boolean update1(String hql,Object...params){
		Session session=openSession();
		Transaction tran=session.beginTransaction();
		Query query=session.createQuery(hql);
		if(params!=null) {
			for(int i=0;i<params.length;i++) {
				query.setParameter(i, params[i]);
			}
		}
		boolean flag=query.executeUpdate()>0;
		tran.commit();
		session.close();
		return flag;
	}
	
	public <T> List<T> list(String hql,Object...objects) {
		List<T> list = new ArrayList<T>();
		Session session = openSession();
		Query query = session.createQuery(hql);
		for(int i=0;i<objects.length;i++){
			query.setParameter(i,objects[i]);
		}
		
		list = query.list();
		session.close();
		return list;
	}
	

}

转载于:https://www.cnblogs.com/LingRenne/p/7821132.html