zoukankan      html  css  js  c++  java
  • hibernate 总结

    1. 1、加入junit.jar

      2、新建一个工具类HibernateUtils.Java把一些对session的公共操作封装起来

    2. public class HibernateUtils {  
    3. /* 
    4.   *读取Hibernate.cfg.xml文件 
    5. */  
    6.     private static SessionFactory factory;  
    7.       
    8.     static {  
    9.         try {  
    10.             //读取hibernate.cfg.xml文件  
    11.             Configuration cfg = new Configuration().configure();  
    12.               
    13.             //建立SessionFactory  
    14.             factory = cfg.buildSessionFactory();  
    15.         }catch(Exception e) {  
    16.             e.printStackTrace();  
    17.         }  
    18.     }  
    19.     /* 
    20.       *打开Session 
    21.     */  
    22.       
    23.     public static Session getSession() {  
    24.         return factory.openSession();  
    25.     }   
    26.     /* 
    27.       *关闭Session 
    28.     */  
    29.       
    30.     public static void closeSession(Session session) {  
    31.         if (session != null) {  
    32.             if (session.isOpen()) {  
    33.                 session.close();  
    34.             }  
    35.         }  
    36.     }  
    37.       
    38.     public static SessionFactory getSessionFactory() {  
    39.         return factory;  
    40.     }  
    1. public class test extends TestCase {  
    2. /* 
    3.  * 增加User 
    4.  */  
    5.     public void testSave() {  
    6.           
    7.         Session session = null;  
    8.         try {  
    9.             session = HibernateUtils.getSession();  
    10.             session.beginTransaction();  
    11.               
    12.             User user = new User();  
    13.             user.setName("李四");  
    14.             user.setPassword("123");  
    15.             user.setCreateTime(new Date());  
    16.             user.setExpireTime(new Date());  
    17.             session.save(user);  
    18.             session.getTransaction().commit();  
    19.         }catch(Exception e) {  
    20.             e.printStackTrace();  
    21.             session.getTransaction().rollback();  
    22.         }finally {  
    23.             HibernateUtils.closeSession(session);  
    24.         }  
    25.     }  
    26.     /** 
    27.      * 删除 
    28.      */  
    29.     public void testDel(){  
    30.         Session session = null;  
    31.         try {  
    32.             session = HibernateUtils.getSession();  
    33.             session.beginTransaction();  
    34.               
    35.             User user=(User)session.load(User.class, "4028989545a244640145a24466300001");  
    36.               
    37.             session.delete(user);  
    38.             session.getTransaction().commit();  
    39.         }catch(Exception e) {  
    40.             e.printStackTrace();  
    41.             session.getTransaction().rollback();  
    42.         }finally {  
    43.             HibernateUtils.closeSession(session);  
    44.         }  
    45.     }  
    46.       
    47.     /** 
    48.      * 修改 
    49.      */  
    50.     public void testUpdate(){  
    51.         Session session = null;  
    52.         try {  
    53.             session = HibernateUtils.getSession();  
    54.             session.beginTransaction();  
    55.               
    56.             User user=(User)session.load(User.class, "4028989545a243ca0145a243cbf80001");  
    57.             user.setName("王五");  
    58.             session.update(user);  
    59.             session.getTransaction().commit();  
    60.         }catch(Exception e) {  
    61.             e.printStackTrace();  
    62.             session.getTransaction().rollback();  
    63.         }finally {  
    64.             HibernateUtils.closeSession(session);  
    65.         }  
    66.     }  
    67.       
    68.     /** 
    69.      * 查询 
    70.      */  
    71.     public void testLoad(){  
    72.         Session session = null;  
    73.         try {  
    74.             session = HibernateUtils.getSession();  
    75.             session.beginTransaction();  
    76.               
    77.             User user=(User)session.load(User.class, "4028989545a243ca0145a243cbf80001");  
    78.             System.out.println(user.getName());  
    79.             System.out.println(user.getId());  
    80.             System.out.println(user.getPassword());  
    81.             System.out.println(user.getClass());  
    82.             System.out.println(user.getCreateTime());  
    83.             System.out.println(user.getExpireTime());  
    84.             session.getTransaction().commit();  
    85.         }catch(Exception e) {  
    86.             e.printStackTrace();  
    87.             session.getTransaction().rollback();  
    88.         }finally {  
    89.             HibernateUtils.closeSession(session);  
    90.         }  
    91.     }  
       
    • load, get区别:

    load返回的代理对象, 真正用到对象时才发出sql语句, 

    get直接从数据库加载,发出sql语句, 不会延迟.

    所以load必须在commit之前执行getName方法的操作.

    但是get放在commit之前之后都可以.

    @Test
        public void testLoad() {
         
            Session session = sessionFactory.getCurrentSession();
            session.beginTransaction();
            Teacher t = (Teacher)session.load(Teacher.class, 1);  //此数字是ID
             
            System.out.println(t.getName());       
            session.getTransaction().commit();
            //System.out.println(t.getClass());
        }
         
        @Test
        public void testGet() {
         
            Session session = sessionFactory.getCurrentSession();
            session.beginTransaction();
            Teacher t = (Teacher)session.get(Teacher.class, 1);
     
            session.getTransaction().commit();
            //System.out.println(t.getClass());
            System.out.println(t.getName());
        }
     

    学过hibernate的人都可能都知道hibernate有三种状态,transient(瞬时状态),persistent(持久化状态)以及 detached(离线状态),大家伙也许也知道这三者之间的区别,比如瞬时状态就是刚new出来一个对象,还没有被保存到数据库中,持久化状态就是已经 被保存到数据库中,离线状态就是数据库中有,但是session中不存在该对象。但是大家又是否对hibernate的session的那几个特殊方法一 清二楚呢?或者说大家是否能够一眼就快速看出一个测试用例在反复的调用session的诸如save,update方法后会到底发出多少条SQL语句呢? 本篇随笔将会给你答案,本篇随笔将会以大量的测试用例来掩饰hibernate的这三种状态的转变,相信看完本篇随笔的你会对hibernate的那三种 状态有更深入的理解。

    好了,废话不多说了,相信大家都知道hibernate的这三种状态的含义,那我们就通过一张图来开始我们的深入hibernate的三种状态之旅吧。

    复制代码
           session = HibernateUtil.openSession();
                session.beginTransaction();
                User user = new User();
                user.setUsername("aaa");
                user.setPassword("aaa");
                user.setBorn(new Date());
                /*
                 *  以上user就是一个Transient(瞬时状态),此时user并没有被session进行托管,即在session的
                 *  缓存中还不存在user这个对象,当执行完save方法后,此时user被session托管,并且数据库中存在了该对象
                 *  user就变成了一个Persistent(持久化对象)
                 */
                session.save(user);
                session.getTransaction().commit();
     
  • 相关阅读:
    vue中使用sass
    vue2项目使用axios发送请求
    css正方形贴图
    用vue-cli 工具搭建项目
    反调试与破反调试笔记
    低功耗蓝牙UUID三种格式转换
    【原创】Android 5.0 BLE低功耗蓝牙从设备应用
    金山助手流氓软件-被进程sjk_daemon.exe坑死
    bower安装教程
    intellij idea快捷键
  • 原文地址:https://www.cnblogs.com/chizizhixin/p/5420679.html
Copyright © 2011-2022 走看看