hibernate辅助类含分页

 package com.cy.utils;

 import java.io.Serializable;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.hibernate.HibernateException;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
 import org.hibernate.cfg.Configuration;
 import org.hibernate.service.ServiceRegistry;

 /**
  * Hibernate辅助类
  *
  * @author renchang
  *
  */
 public class HibernateUtils {

     private static Configuration config; // 配置对象
     private static ServiceRegistry ser; // 服务
     private static SessionFactory sf; // session工厂
     private static Session session; // session
     private static Transaction transaction; // 事务

     /**
      * 1.读取配置到Configuration 2.注册服务 3.获得SessionFactory
      */
     static {
         config = new Configuration().configure();
         ser = new StandardServiceRegistryBuilder().applySettings(
                 config.getProperties()).build();
         sf = config.buildSessionFactory(ser);
     }

     /**
      * 获得Session
      *
      * @return session对象
      */
     public static Session getSession() {
         return session = sf.openSession();
     }

     /**
      * 获得事务对象
      *
      * @return Transaction对象
      */
     public static Transaction getTransaction() {
         return transaction = session.beginTransaction();
     }

     /**
      * 关闭资源
      */
     public static void close() {
         try {
             session.close();
         } catch (HibernateException e) {
             e.printStackTrace();
         }
     }

     /**
      * 添加新数据
      *
      * @param obj
      *            待添加的对象
      */
     public static void save(Object obj) {
         try {
             getSession();
             getTransaction();
             session.save(obj);
             transaction.commit();
         } catch (Exception e) {
             e.printStackTrace();
             transaction.rollback();
         } finally {
             close();
         }
     }

     /**
      * 修改数据
      *
      * @param obj
      *            待修改的对象
      */
     public static void update(Object obj) {
         try {
             getSession();
             getTransaction();
             session.update(obj);
             transaction.commit();
         } catch (Exception e) {
             e.printStackTrace();
             transaction.rollback();
         } finally {
             close();
         }
     }

     /**
      * 添删除数据
      *
      * @param obj
      *            待删除的对象
      */
     public static void delete(Object obj) {
         try {
             getSession();
             getTransaction();
             session.delete(obj);
             transaction.commit();
         } catch (Exception e) {
             e.printStackTrace();
             transaction.rollback();
         } finally {
             close();
         }
     }

     /**
      * 按条件插叙数据
      *
      * @param hql
      *            插叙的hql语句
      * @param whereMap
      *            插叙条件的键值对
      * @return 满足条件的对象集合
      */
     public static List<?> find(String hql, Map<String, Object> whereMap) {
         List<?> objList = null;
         try {
             getSession();
             getTransaction();
             getTransaction();
             hql = setHql(hql, whereMap);
             Query query = session.createQuery(hql);
             objList = query.list();
             transaction.commit();
         } catch (Exception e) {
             e.printStackTrace();
             transaction.rollback();
         } finally {
             close();
         }
         return objList;
     }

     /**
      * 根据id获得对象信息
      *
      * @param cls
      *            对象z
      * @param id
      *            id
      * @return 对象
      */
     public static Object getObjById(Class<?> cls, Serializable id) {
         Object obj = null;
         try {
             getSession();
             getTransaction();
             obj = session.get(cls, id);
             transaction.commit();
         } catch (Exception e) {
             e.printStackTrace();
             transaction.rollback();
         } finally {
             close();
         }
         return obj;
     }

     /**
      * 分页
      *
      * @param hql
      *            分页语句
      * @param pageSize
      *            每页大小
      * @param pageNo
      *            当前页数
      * @param whereMap
      *            分页条件
      * @return 满足条件的数据
      */
     public static List<?> paging(String hql, int pageSize, int pageNo,
             Map<String, Object> whereMap) {
         List<?> objList = null;
         try {
             getSession();
             getTransaction();
             getTransaction();
             hql = setHql(hql, whereMap);
             Query query = session.createQuery(hql);
             int beginRow = (pageNo - 1) * pageSize;
             query.setFirstResult(beginRow);
             query.setMaxResults(pageSize);
             objList = query.list();
             transaction.commit();
         } catch (Exception e) {
             e.printStackTrace();
             transaction.rollback();
         } finally {
             close();
         }
         return objList;
     }

     /**
      * 获得条件下总条数
      *
      * @param hql
      *            hql语句
      * @param whereMap
      *            统计的总条数
      * @return 总条数
      */
     public static int getTotalRows(String hql, Map<String, Object> whereMap) {
         int totalRows = 0;
         try {
             getSession();
             getTransaction();
             hql = setHql(hql, whereMap);
             Query query = session.createQuery(hql);
             totalRows = (new Integer(query.uniqueResult().toString()))
                     .intValue();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             close();
         }
         return totalRows;
     }

     /**
      * 拼接hql语句
      *
      * @param hql
      *            原始hql语句
      * @param whereMap
      *            拼接的条件
      * @return 拼接后的hql
      */
     private static String setHql(String hql, Map<String, Object> whereMap) {
         StringBuffer sbHql = new StringBuffer(hql);
         if (whereMap != null) {
             Set<String> set = whereMap.keySet();
             Iterator<String> it = set.iterator();
             while (it.hasNext()) {
                 String key = it.next();
                 sbHql.append(" AND " + key + " LIKE '%" + whereMap.get(key)
                         + "%'");
             }
         }
         return sbHql.toString();
     }
 }