javan

          i like java
          隨筆 - 0, 文章 - 28, 評論 - 2, 引用 - 0
          數據加載中……

          hibernate持久換機制,以及session的evict、flush方法 綜合例子

          1. /** 
          2.      * 測試uuid主鍵生成策略 
          3.      */  
          4.     public void testSave1() {  
          5.         Session session = null;  
          6.         Transaction tx = null;  
          7.         try {  
          8.             session = HibernateUtils.getSession();  
          9.             tx = session.beginTransaction();  
          10.   
          11.             User1 user = new User1();  
          12.             user.setName("李四");  
          13.             user.setPassword("123");  
          14.             user.setCreateTime(new Date());  
          15.             user.setExpireTime(new Date());  
          16.               
          17.             //因為user的主鍵生成側路采用的是uuid,所以調用完成save后,只是將user納入到了session的管理  
          18.             //不會發出insert語句,但是id已經生成,session中existsInDatebase狀態為false  
          19.             session.save(user);  
          20.               
          21.             //調用flush,hibernate會清理緩存,執行sql  
          22.             //如果數據庫的隔離級別設置為為提交讀,那么我們可以看到flush過的數據  
          23.             //并且session中existsInDatebase狀態為true  
          24.             session.flush();  
          25.               
          26.             //提交事務  
          27.             //默認情況下commit操作會先執行flush清理緩存,所以不用顯示的調用flush  
          28.             //commit后數據是無法回滾的  
          29.             tx.commit();  
          30.         }catch(Exception e) {  
          31.             e.printStackTrace();  
          32.             tx.rollback();  
          33.         }finally {  
          34.             HibernateUtils.closeSession(session);  
          35.         }  
          36.     }  
          37.       
          38.     /** 
          39.      * 測試native主鍵生成策略 
          40.      */  
          41.     public void testSave2() {  
          42.         Session session = null;  
          43.         Transaction tx = null;  
          44.         try {  
          45.             session = HibernateUtils.getSession();  
          46.             tx = session.beginTransaction();  
          47.   
          48.             User2 user = new User2();  
          49.             user.setName("張三1");  
          50.             user.setPassword("123");  
          51.             user.setCreateTime(new Date());  
          52.             user.setExpireTime(new Date());  
          53.               
          54.             //因為user的主鍵生成策略為native,所以調用session.save后,將執行insert語句,返回有數據庫生成的id  
          55.             //納入了session的管理,修改了session中existsInDatebase狀態為true  
          56.             //如果數據庫的隔離級別設置為為提交讀,那么我們可以看到save過的數據  
          57.             session.save(user);  
          58.             tx.commit();  
          59.         }catch(Exception e) {  
          60.             e.printStackTrace();  
          61.             tx.rollback();  
          62.         }finally {  
          63.             HibernateUtils.closeSession(session);  
          64.         }  
          65.     }  
          66.       
          67.       
          68.     /** 
          69.      * 測試uuid主鍵生成策略 
          70.      */  
          71.     public void testSave3() {  
          72.         Session session = null;  
          73.         Transaction tx = null;  
          74.         try {  
          75.             session = HibernateUtils.getSession();  
          76.             tx = session.beginTransaction();  
          77.   
          78.             User1 user = new User1();  
          79.             user.setName("王五");  
          80.             user.setPassword("123");  
          81.             user.setCreateTime(new Date());  
          82.             user.setExpireTime(new Date());  
          83.               
          84.             //因為user的主鍵生成側路采用的是uuid,所以調用完成save后,只是將user納入到了session的管理  
          85.             //不會發出insert語句,但是id已經生成,session中existsInDatebase狀態為false  
          86.             session.save(user);  
          87.               
          88.             //將user對象從session中逐出,即session的EntityEntries屬性中逐出  
          89.             session.evict(user);  
          90.               
          91.             //無法成功提交,因為hibernate在清理緩存時,在session的insertions集合中取出user對象進行insert操作后  
          92.             //需要更新entityEntries屬性中的existsInDatabase為true,而我們采用evict已經將user從session的entityEntries  
          93.             //中逐出了,所以找不到相關數據,無法更新,拋出異常  
          94.             tx.commit();  
          95.         }catch(Exception e) {  
          96.             e.printStackTrace();  
          97.             tx.rollback();  
          98.         }finally {  
          99.             HibernateUtils.closeSession(session);  
          100.         }  
          101.     }  
          102.       
          103.     /** 
          104.      * 測試uuid主鍵生成策略 
          105.      */  
          106.     public void testSave4() {  
          107.         Session session = null;  
          108.         Transaction tx = null;  
          109.         try {  
          110.             session = HibernateUtils.getSession();  
          111.             tx = session.beginTransaction();  
          112.   
          113.             User1 user = new User1();  
          114.             user.setName("王五");  
          115.             user.setPassword("123");  
          116.             user.setCreateTime(new Date());  
          117.             user.setExpireTime(new Date());  
          118.               
          119.             //因為user的主鍵生成側路采用的是uuid,所以調用完成save后,只是將user納入到了session的管理  
          120.             //不會發出insert語句,但是id已經生成,session中existsInDatebase狀態為false  
          121.             session.save(user);  
          122.               
          123.             //flush后hibernate會清理緩存,會將user對象保存到數據庫中,將session中的insertions中的user對象  
          124.             //清除,并且設置session中existsInDatebase的狀態為true  
          125.             session.flush();  
          126.               
          127.             //將user對象從session中逐出,即session的EntityEntries屬性中逐出  
          128.             session.evict(user);  
          129.               
          130.             //可以成功提交,因為hibernate在清理緩存時,在session的insertions集合中無法找到user對象  
          131.             //所以就不會發出insert語句,也不會更新session中的existsInDatabase的狀態  
          132.             tx.commit();  
          133.         }catch(Exception e) {  
          134.             e.printStackTrace();  
          135.             tx.rollback();  
          136.         }finally {  
          137.             HibernateUtils.closeSession(session);  
          138.         }  
          139.     }  
          140.       
          141.     /** 
          142.      * 測試native主鍵生成策略 
          143.      */  
          144.     public void testSave5() {  
          145.         Session session = null;  
          146.         Transaction tx = null;  
          147.         try {  
          148.             session = HibernateUtils.getSession();  
          149.             tx = session.beginTransaction();  
          150.   
          151.             User2 user = new User2();  
          152.             user.setName("張三11");  
          153.             user.setPassword("123");  
          154.             user.setCreateTime(new Date());  
          155.             user.setExpireTime(new Date());  
          156.               
          157.             //因為user的主鍵生成策略為native,所以調用session.save后,將執行insert語句,返回有數據庫生成的id  
          158.             //納入了session的管理,修改了session中existsInDatebase狀態為true  
          159.             //如果數據庫的隔離級別設置為為提交讀,那么我們可以看到save過的數據  
          160.             session.save(user);  
          161.               
          162.             //將user對象從session中逐出,即session的EntityEntries屬性中逐出  
          163.             session.evict(user);  
          164.               
          165.             //可以成功提交,因為hibernate在清理緩存時,在session的insertions集合中無法找到user對象  
          166.             //所以就不會發出insert語句,也不會更新session中的existsInDatabase的狀態  
          167.             tx.commit();  
          168.         }catch(Exception e) {  
          169.             e.printStackTrace();  
          170.             tx.rollback();  
          171.         }finally {  
          172.             HibernateUtils.closeSession(session);  
          173.         }  
          174.     }  
          175.       
          176.     /** 
          177.      * 測試assigned主鍵生成策略 
          178.      *  
          179.      */  
          180.     public void testSave6() {  
          181.         Session session = null;  
          182.         Transaction tx = null;  
          183.         try {  
          184.             session = HibernateUtils.getSession();  
          185.             tx = session.beginTransaction();  
          186.   
          187.             User3 user = new User3();  
          188.             user.setId("001");  
          189.             user.setName("張三");  
          190.               
          191.             session.save(user);  
          192.               
          193.             user.setName("王五");  
          194.             session.update(user);  
          195.               
          196.             User3 user3 = new User3();  
          197.             user3.setId("002");  
          198.             user3.setName("李四");  
          199.             session.save(user3);  
          200.               
          201.             //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
          202.             //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
          203.             //Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?  
          204.             //hibernate按照save(insert),update、delete順序提交相關操作  
          205.             tx.commit();  
          206.         }catch(Exception e) {  
          207.             e.printStackTrace();  
          208.             tx.rollback();  
          209.         }finally {  
          210.             HibernateUtils.closeSession(session);  
          211.         }  
          212.     }     
          213.       
          214.     /** 
          215.      * 測試assigned主鍵生成策略 
          216.      *  
          217.      */  
          218.     public void testSave7() {  
          219.         Session session = null;  
          220.         Transaction tx = null;  
          221.         try {  
          222.             session = HibernateUtils.getSession();  
          223.             tx = session.beginTransaction();  
          224.   
          225.             User3 user = new User3();  
          226.             user.setId("003");  
          227.             user.setName("張三");  
          228.               
          229.             session.save(user);  
          230.               
          231.             user.setName("王五");  
          232.             session.update(user);  
          233.               
          234.             session.flush();  
          235.               
          236.             User3 user3 = new User3();  
          237.             user3.setId("004");  
          238.             user3.setName("李四");  
          239.             session.save(user3);  
          240.               
          241.             //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
          242.             //Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?  
          243.             //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
          244.             //因為我們在session.udpate(user)后執行了flush,所以在清理緩存時執行flush前的sql不會生成  
          245.             //sql會按照我們的意愿執行  
          246.             tx.commit();  
          247.         }catch(Exception e) {  
          248.             e.printStackTrace();  
          249.             tx.rollback();  
          250.         }finally {  
          251.             HibernateUtils.closeSession(session);  
          252.         }  
          253.     } 

          posted on 2009-06-09 10:19 whl 閱讀(712) 評論(0)  編輯  收藏


          只有注冊用戶登錄后才能發表評論。


          網站導航:
           
          主站蜘蛛池模板: 丘北县| 酉阳| 南漳县| 思南县| 武鸣县| 宣化县| 康定县| 聂荣县| 涞源县| 桦川县| 上高县| 颍上县| 集安市| 台安县| 原阳县| 全椒县| 同江市| 凤山市| 抚宁县| 巴林右旗| 毕节市| 烟台市| 常宁市| 开封县| 明溪县| 永济市| 铁岭市| 革吉县| 上饶市| 陵川县| 镶黄旗| 织金县| 铜山县| 贵州省| 隆化县| 滁州市| 平顶山市| 固阳县| 嘉荫县| 南召县| 八宿县|