Hibernate【2】——封装工具、HibernateUtil类以及DAO层的BaseDAO类

参考博文：http://blog.csdn.net/hanhan313/article/details/8125924

1、整体目录

（1）添加一个HibernateUtil类（获取会话）

（2）添加一个BaseDAO类（基本操作）

（3）添加一个测试类

2、HibernateUtil

package com.demo.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtil {
      private static SessionFactory sessionFactory;
      
      /**
      * @return 获取会话工厂
      */
       public static SessionFactory getSessionFactory()
       {
         //第一步:读取Hibernate的配置文件  hibernamte.cfg.xml文件
         Configuration con=new Configuration().configure();
         //第二步:创建服务注册构建器对象，通过配置对象中加载所有的配置信息
         ServiceRegistryBuilder regbulider=new ServiceRegistryBuilder().applySettings(con.getProperties());
         //创建注册服务
         ServiceRegistry reg=regbulider.buildServiceRegistry();
         //第三步:创建会话工厂
         SessionFactory sessionFactory=con.buildSessionFactory(reg);
         return sessionFactory;
       }
       
      /**
      * @return 获取会话对象
      */
       public static Session getSession()
       {
          return getSessionFactory().openSession();
       }
}

3、BaseDAO类

package com.demo.dao;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.demo.util.HibernateUtil;

public class BaseDAO {
      /**
     * @param obj 添加数据
     * @return
     */
      public static boolean add(Object obj)
      {
        Session session=null;
        Transaction tran=null;
        boolean result=false;
        try
        {
            session=HibernateUtil.getSession();
            tran=session.beginTransaction();
            session.save(obj);
            tran.commit();
            result=true;
        }
        catch (Exception e)
        {
           if(tran!=null)
           {
               //事物回滚
               tran.rollback();
           }
        }
        finally
        {
            if(session!=null)
            {
                //关闭session
                session.close();
            }
        }
        return result;
      }
      
      /**
     * @return 更新数据 
     * 参数为修改的主键id对象
     */
    public static boolean update(Object object)
      {
            Session session=null;
            Transaction tran=null;
            boolean result=false;
            try
            {
                session=HibernateUtil.getSession();
                tran=session.beginTransaction();
                session.update(object);
                tran.commit();
                result=true;
            }
            catch (Exception e)
            {
               if(tran!=null)
               {
                   //事物回滚
                   tran.rollback();
               }
            }
            finally
            {
                if(session!=null)
                {
                    //关闭session
                    session.close();
                }
            }
            return result;
          }
         
      /**
     * @param c
     * @param id  查询一条数据根据主键的id号
     * @return
     */
      public static Object get(Class c,int id)
      {
            Session session=null;
            Object object=null;
            try
            {
                session=HibernateUtil.getSession();
                object=session.get(c,id);
            }
            catch (Exception e)
            {
            }
            finally
            {
                if(session!=null)
                {
                    //关闭session
                    session.close();
                }
            }
            return object;
      }

      /**
     * @param obj
     * @return 删除数据
     */
    public static boolean delete(Object obj)
      {
            Session session=null;
            Transaction tran=null;
            boolean result=false;
            try
            {
                session=HibernateUtil.getSession();
                tran=session.beginTransaction();
                session.delete(obj);
                tran.commit();
                result=true;
            }
            catch (Exception e)
            {
               if(tran!=null)
               {
                   //事物回滚
                   tran.rollback();
               }
            }
            finally
            {
                if(session!=null)
                {
                    //关闭session
                    session.close();
                }
            }
            return result;
      }


      /**
     * @param <T> 查询多条记录
     * @param sql  sql语句
     * @param param 参数数组
     * @return
     */
     @SuppressWarnings("unchecked")
    public static <T> List<T> query(String sql,String[] param)
      {

          List<T> list=new ArrayList<T>();
          Session session=null;
           try
            {
                session=HibernateUtil.getSession();
                Query query=session.createQuery(sql);
                if(param!=null)
                {
                    for(int i=0;i<param.length;i++)
                    {
                        query.setString(i,param[i]);    
                    }
                }
                list=query.list();
            }
            catch (Exception e)
            {
            }
            finally
            {
                if(session!=null)
                {
                    session.close();
                }
            }
          return list;
      }
      /**
     * @param sql
     * @param param 查询单条记录
     * @return
     */
    public static Object queryOne(String sql,String[] param)
      {
          Object object=null;
          Session session=null;
           try
            {
                session=HibernateUtil.getSession();
                Query query=session.createQuery(sql);
                if(param!=null)
                {
                    for(int i=0;i<param.length;i++)
                    {
                        query.setString(0,param[i]);    
                    }
                    object=query.uniqueResult();
                }
            }
            catch (Exception e)
            {
            }
            finally
            {
                if(session!=null)
                {
                    session.close();
                }
            }
          return object;
      }
    /**
     * @param <T>
     * @param sql
     * @param param
     * @param page
     * @param size
     * @return 实现分页查询
     */
    @SuppressWarnings("unchecked")
    public static <T> List<T> queryByPage(String sql,String[] param,int page,int size)
      {
          List<T> list=new ArrayList<T>();
          Session session=null;
           try
            {
                session=HibernateUtil.getSession();
                Query query=session.createQuery(sql);
                if(param!=null)
                {
                    for(int i=0;i<param.length;i++)
                    {
                        query.setString(i,param[i]);    
                    }
                }
                //筛选条数
                query.setFirstResult((page-1)*size);
                query.setMaxResults(size);
                list=query.list();
            }
            catch (Exception e)
            {
            }
            finally
            {
                if(session!=null)
                {
                    session.close();
                }
            }
          return list;
      }
    /**
     * @param hql
     * @param pras
     * @return返回数据个数
     */
    public static int getCount(String hql, String[] pras) {
        int resu = 0;
        Session s = null;
        try {
            s = HibernateUtil.getSession();
            Query q = s.createQuery(hql);
            if (pras != null) {
                for (int i = 0; i < pras.length; i++) {
                    q.setString(i, pras[i]);
                }
            }
            resu = Integer.valueOf(q.iterate().next().toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (s != null)
                s.close();
        }
        return resu;
    }
     

}

4、TestHibernateUtil类

package com.demo.test;

import java.util.Iterator;
import java.util.List;

import com.demo.dao.BaseDAO;
import com.demo.model.User;

public class TestHibernateUtil {
    public static void main(String[] args) {
        
        BaseDAO userDao = new BaseDAO();
        //add
        User user1 = new User();
        user1.setUserName("asdf");
        user1.setUserPwd("1234");
        userDao.add(user1);
        System.out.println("添加了一条数据：asdf-->1234");
        //get
        User user2 = (User)userDao.get(User.class, 6);
        System.out.println("用户ID为6的用户数据："+user2.getUserName()+"-->"+user2.getUserPwd());
        //update
        user2.setUserName("test");
        user2.setUserPwd("789");
        userDao.update(user2);
        System.out.println("用户ID为6的用户数据："+user2.getUserName()+"-->"+user2.getUserPwd());
        //query all
        String[] para ={"3"};
        List<User> list = userDao.query("from User u where u.id=?", para);
        Iterator iter = list.iterator();
        User user3 = null;
        while(iter.hasNext()){
            user3 = (User)iter.next();
            System.out.println(user3.getUserName()+"-->"+user3.getUserPwd());
        }
        
        
        //del by id
/*        User user4 = new User();
        user4.setId(5);
        userDao.delete(user4);
        System.out.println("删除了ID为5的用户！");
*/    }
}