Hibernate4.x之Session--常用方法

接上篇文章繼續學習Hibernate的Session(http://www.cnblogs.com/dreamfree/p/4111777.html)

持久化對象的狀態;
　　站在持久化的角度，Hibernate把對象分為4種狀態：持久化狀態、臨時狀態、游離狀態、刪除狀態。
　　Session的特定方法能使對象從一個狀態轉換到另一個狀態。

　　臨時對象(Transient):
　　　　在使用代理主鍵的情況下，OID通常為null
　　　　不處於Session的緩存中
　　　　在數據庫中沒有對應的記錄
　　持久化對象(也叫“托管”)(Persist)
　　　　OID為null
　　　　位於Session緩存中
　　　　若在數據庫中已經有和其對應的記錄，持久化對象和數據庫中的相關記錄對應
　　　　Session在flush緩存時，會根據持久化對象的屬性變化，來同步更新數據庫
　　　　在同一個Session實例的緩存中，數據庫表中的每條記錄只對應唯一的持久化對象
　　刪除對象(Removed):
　　　　在數據庫中沒有和其OID對應的記錄
　　　　不再處於Session緩存中
　　　　一般情況下，應用程序不該再使用被刪除的對象
　　游離對象(也叫"脫管")(Detached):
　　　　OID不為null
　　　　不再處於Session緩存中
　　　　一般情況下，游離對象是由持久化對象轉變過來的，因此在數據庫中可能還存在與它對應的記錄

下面的圖片說明了Hibernate中對象狀態的轉換：

Session的save方法
　　Session的save()方法使一個臨時對象轉變為持久化對象
　　Session的save()方法完成以下操作：
　　　　把News對象加入到Session緩存中，使它進入持久化狀態
　　　　選用映射文件指定的標識符生成器，為持久化對象分配唯一的OID，在使用代理主鍵的情況下，setId()方法為News對象設置OID是無效的
　　　　計划執行一條insert語句：在flush緩存的時候
　　Hibernate通過持久化對象的OID來維持它和數據庫相關記錄的對應關系。當News對象處於持久化狀態時，不允許程序隨意修改它的ID

　　persist()和save()的區別：
　　　　當對一個OID不為null的對象執行save()方法時，會把該對象以一個新的OID保存到數據庫中；但執行persist()方法時會拋出一個異常

Session的get()和load()方法
　　都可以根據給定的OID從數據庫加載一個持久化對象
區別：
　　當數據庫中不存在與OID對應的記錄時，load()方法拋出ObjectNotFoundException異常，而get()方法返回null
　　兩者采用不同的延遲檢索策略：load()方法支持延遲加載策略。而get不支持

Session的update()方法
　　Session的update()方法使一個游離對象轉變為持久化對象，並且計划執行一條update語句
　　若希望Session僅當修改了News對象的屬性時，才執行update()語句，可以把映射文件中<class>元素的select-before-update設為true。該屬性的默認值為false
　　當update()方法關聯一個游離對象時，如果在Session的緩存中已經存在相同的OID的持久化對象，會拋出異常
　　當update()方法關聯一個游離對象時，如果數據庫中不存在相應的記錄，也會拋出異常

Session的saveOrUpdate()方法
　　Session的saveOrUpdate()方法同時包含了save()與update()方法的功能

　　

　　

判定對象為臨時對象的標准
　　Java對象的OID為null
　　映射文件中的<id>設置了unsaved-value屬性，並且Java對象的OID取值與這個unsaved-value屬性值匹配

Session的merge()方法

　　

　　

Session的delete()方法
　　Session的delete()方法既可以刪除一個游離對象，也可以刪除一個持久化對象
　　Session的delete()方法處理過程
　　計划執行一條delete語句
　　把對象從Session的緩存中刪除，該對象進入刪除狀態
　　Hibernate的cfg.xml配置文件中有一個hibernate.use_identifier_rollback屬性，其默認值為false，若把它設為true，將改變delete()方法的運行行為：delete()方法會把持久化對象或游離對象的OID設置為null，使它們變為臨時對象

通過Hibernate調用存儲過程
　　work接口：直接通過JDBC API來訪問數據庫的操作

　　Session的doWork(Work)方法用於執行Work對象指定的操作，即調用Work對象的execute()方法。Session會把當前使用的數據庫連接傳遞給execute()方法

Hibernate與觸發器協同工作
　　Hibernate與數據庫中的觸發器協同工作時，會造成兩類問題
　　　　觸發器使Session的緩存中的持久化對象與數據庫中對應的數據不一致；觸發器運行在數據庫中，它執行的操作對Session是透明的
　　　　session的update()方法盲目地激發觸發器；無論游離對象的屬性是否發生變化，都會執行update語句，而update語句會激發數據庫中相應的觸發器
解決方案：
　　在執行完Session的相關操作后，立即調用Session的flush()方法和refresh()方法，迫使Session的緩存與數據庫同步(refresh()方法重新從數據庫加載對象)

　　在映射文件的<class>元素中設置select-before-update屬性；當Session的update或saveOrUpdate()方法更新一個游離對象時，會先執行select語句，獲得當前游離對象在數據庫中的最新數據。只有在一致的情況下才會執行update語句

 

測試類：

package com.yl.hibernate.entities;

import static org.junit.Assert.*;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HibernateTest {

    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;
    
    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = 
                new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                                            .buildServiceRegistry();

        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        
        session = sessionFactory.openSession();

        transaction = session.beginTransaction();
    }
    @After
    public void destory() {
        transaction.commit();
        
        session.close();
        
        sessionFactory.close();
    }
    
    @Test
    public void testSessionCache() {
        News news = (News)session.get(News.class, 21);
        System.out.println(news);
        session.flush();
        News news2 = (News)session.get(News.class, 21);
        System.out.println(news2);
        
        System.out.println(news == news2);//true
    }

    /**
     * flush：使數據庫表中的記錄和Session緩存中的對象的狀態保持一致。為了保持一致，則可能會發送對應的SQL語句。
     *     1.在Transaction的commit()方法中：先調用session的flush方法，再提交事務
     *  2.flush()方法可能會發送SQL語句，但不會提交事務
     *  3.注意：在為提交事務或顯示調用session.flush()方法 之前，也有可能會flush()操作。
     *      1).執行HQL或QBC查詢，會先進行flush操作，以得到數據表的最新紀錄
     *      2).若記錄的ID是由底層數據庫使用自增的方式生成的，則在調用save方法時，就會立即發送INSERT語句
     *  因為save方法后，必須保證對象的ID是存在的！
     */
    @Test
    public void testFlush2() {
        News news = new News("Hibernate", "oracle", new Date());
        session.save(news);
    }
    
    @Test
    public void testFlush() {
        /*News news = (News)session.get(News.class, 21);
        news.setAuthor("Bruce Eckel");
        
        News news2 = (News)session.createCriteria(News.class).uniqueResult();
        System.out.println(news2);*/
        News news = (News)session.get(News.class, 22);
        session.flush();
        System.out.println(news);
    }
    
    /**
     * refresh():會強制發送SELECT 語句，以使Session緩存中對象的狀態和數據表中對應的記錄保持一致！
     */
    @Test
    public void testRefresh() {
        News news = (News) session.get(News.class, 22);
        System.out.println(news);
        session.refresh(news);
        System.out.println(news);
    }
    
    /**
     * clear():清理緩存
     */
    @Test
    public void testClear() {
        News news1 = (News) session.get(News.class, 21);
        session.clear();
        News news2 = (News) session.get(News.class, 21);
    }
    
    /**
     * save()方法：
     *     1.使一個臨時對象變為持久化對象
     *     2.為對象分配ID
     *     3.在flush緩存時會發送一條insert語句
     *     4.在save方法之前的id是無效的
     *     5.持久化對象的ID是不能被修改的！
     */
    @Test
    public void testSave() {
        News news = new News();
        news.setTitle("AA");
        news.setAuthor("aa");
        news.setNewsDate(new Date());
        //news.setId(100);//不起效果
        System.out.println(news);
        //news.setId(101);//拋出異常
        session.save(news);
        System.out.println(news);
    }
    /**
     * persist()：也會執行insert操作
     * 和save()的區別：
     * 在調用persist方法之前，若對象已經有ID了，則不會執行insert，而拋出異常
     */
    @Test
    public void testPsesist() {
        News news = new News();
        news.setTitle("DD");
        news.setAuthor("dd");
        news.setNewsDate(new Date());
        //news.setId(200);//拋出異常
        System.out.println(news);
        session.save(news);
        System.out.println(news);
    }
    
    /**
     * 
     */
    @Test
    public void testGet() {
        News news = (News) session.get(News.class, 21);
        System.out.println(news);
    }
    
    /**
     * get 和   load
     * 
     * 1.執行get方法，會立即加載對象。
     *        而執行load方法，若不使用該對象，則不會立即執行查詢操作，而返回一個代理對象
     * 
     *      get是立即檢索，load是延遲檢索
     * 
     * 2.load方法可能會拋出LazyInitializationException(懶加載異常):在需要初始化代理對象之前已經關閉了session
     * 
     * 3.若數據表中沒有對應的記錄，且session也沒有被關閉。同時需要使用對象時
     *         get 返回null
     *         load 若不使用該對象的任何屬性，則不會出問題；若要初始化了，拋出異常
     * 
     * 
     */
    @Test
    public void testLoad() {
        News news = (News) session.load(News.class, 21);
        System.out.println(news);
    }
    
    /**
     * update:
     * 1.若更新一個持久化對象，不需要顯式的調用update對象。因為在調用Transaction的commit方法時，會先執行session的flush方法。
     * 2.更新一個游離對象，需要顯式的調用session的update方法。可以把一個游離對象變為持久化對象
     * 
     * 需要注意的：
     * 1.無論要更新的游離對象和數據表中的記錄是否一致，都會發送update語句。
     *      如何能讓update方法不再盲目的發送update語句，在.hbm.xml文件的class節點設置select-before-update的值為true,默認為flase。但通常不需要設置該屬性
     * 
     * 2.若數據表中沒有對應的記錄，但還調用了update方法，會拋出異常
     * 
     * 3.當update()方法關聯一個游離對象時，如果在Session的緩存中已經存在相同OID的持久化對象，會拋出異常。因為在Session緩存中不能有兩個OID相同的對象
     */
    @Test
    public void testUpdate() {
        /*News news = (News) session.get(News.class, 22);
        news.setAuthor("Sun");//此時news的author字段已經更新到數據庫中，因為在執行commit語句時會先執行flush，flush將session緩存中的修改同步到數據庫中。
        */
        
        News news = (News) session.get(News.class, 22);
        transaction.commit();
        session.close();
        
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
        
        
        //news.setAuthor("Sun");
        session.update(news);
        
    }
    
    /**
     * 注意：
     * 1.若OID不為空，但數據表還沒有和其對應的記錄。會拋出一個異常。
     * 2.了解：OID值等於id的unsaved-value屬性值的對象，也被認為是一個游離對象
     */
    @Test
    public void testSaveOrUpdate() {
        News news = new News("FF", "ff", new Date());
        news.setId(41);
        session.saveOrUpdate(news);
        
    }
    
    /**
     * delete: 執行刪除操作，只要OID和數據表中一條記錄對應，就會准備執行delete操作
     * 若OID在數據表中沒有對應的記錄，則拋出異常
     * 
     * 可以通過設置一個Hibernate配置文件hibernate.use_identifier_rollback 為true，使刪除對象后，把其OID置為null
     */
    @Test
    public void testDelete() {
        /*//游離對象刪除
        News news = new News();
        news.setId(42);
        
        session.delete(news);*/
        
        //持久化對象刪除
        News news = (News) session.get(News.class, 41);
        session.delete(news);//計划刪除，並不立即執行。在commit中的flush時執行delete
        System.out.println(news);//依然可以打印
    }
    
    /**
     * evict：從session緩存中把指定的持久化對象移除
     */
    @Test
    public void testEvict() {
        News news1 = (News) session.get(News.class, 22);
        News news2 = (News) session.get(News.class, 41);
        
        news1.setTitle("AA");
        news2.setTitle("BB");
        
        session.evict(news1);
    }
    
    /**
     * 調用存儲過程
     */
    @Test
    public void testDoWork() {
        session.doWork(new Work() {
            
            @Override
            public void execute(Connection connection) throws SQLException {
                System.out.println(connection);
                //調用存儲過程
                
                //創建存儲過程的對象  
                CallableStatement c = connection.prepareCall("{call getsum(?,?)}");
                
                //給存儲過程的第一個參數設置值  
                c.setInt(1,100);  
                 
                //注冊存儲過程的第二個參數  
                c.registerOutParameter(2,java.sql.Types.INTEGER);  
                 
                //執行存儲過程  
                c.execute();  
                
                connection.close();
            }
        });
    }
}