Hibernate 框架Session对象

Session 概述

1. Session 接口是 Hibernate 向应用程序提供的操纵数据库的最主要的接口, 它提供了基本的保存, 更新, 删除和加载 Java 对象的方法.
2. Session 具有一个缓存, 位于缓存中的对象称为持久化对象, 它和数据库中的相关记录对应. Session 能够在某些时间点, 按照缓存中对象的变化来执行相关的 SQL 语句, 来同步更新数据库, 这一过程被称为刷新缓存(flush)
3. 站在持久化的角度, Hibernate 把对象分为 4 种状态: 持久化状态, 临时状态, 游离状态, 删除状态. Session 的特定方法能使对象从一个状态转换到另一个状态.

操作Session缓存

对象状态

1. 临时对象（Transient）:
   在使用代理主键的情况下, OID 通常为 null
   不处于 Session 的缓存中
   在数据库中没有对应的记录
2. 持久化对象(也叫”托管”)（Persist）：
   OID 不为 null
   位于 Session 缓存中
   若在数据库中已经有和其对应的记录, 持久化对象和数据库中的相关记录对应
   Session 在 flush 缓存时, 会根据持久化对象的属性变化, 来同步更新数据库
   在同一个 Session 实例的缓存中, 数据库表中的每条记录只对应唯一的持久化对象
3. 删除对象(Removed)
   在数据库中没有和其 OID 对应的记录
   不再处于 Session 缓存中
   一般情况下, 应用程序不该再使用被删除的对象
4. 游离对象(也叫”脱管”) （Detached）：
   OID 不为 null
   不再处于 Session 缓存中
   一般情况需下, 游离对象是由持久化对象转变过来的, 因此在数据库中可能还存在与它对应的记录

对象状态转化图

例子

bean对象和映射文件参考Hibernate框架简介中的News.java和News.hbm.xml。

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>

        <!-- 配置 hibernate 基本连接属性 -->
        <property name="connection.username">root</property>
        <property name="connection.password">12345</property>
        <property name="connection.url">jdbc:mysql:///test</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

        <!-- 配置 hibernate 常用属性 -->
        <!-- 指定数据库所使用的方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <property name="format_sql">true</property>
        <property name="show_sql">true</property>

        <!-- hbm2ddl.auto 指定运行程序是生成数据表的策略 -->
        <property name="hbm2ddl.auto">update</property>

        <!-- 设置 hibernate 事务的隔离级别 -->
        <!-- 1. READ UNCOMMITED
             2. READ COMMITED
             4. REPEATABLE READ
             8. SERIALIZEABLE -->
        <property name="connection.isolation">2</property>

        <!--  使删除对象后, 把其 OID 置为  null，不常使用 -->
        <!-- <property name="use_identifier_rollback">true</property> -->

        <!-- 每次从数据库中取出的记录条数 -->
        <property name="hibernate.jdbc.fetch_size">100</property>
        <!-- 对数据库进行批量删除，批量更新和批量插入的时候的批次大小 -->
        <property name="hibernate.jdbc.batch_size">30</property>

        <!-- 指定需要映射关联的文件 -->
        <mapping resource="com/hibernate/helloworld/News.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

SessionTest.java

package com.hibernate.entities;

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;

import com.hibernate.helloworld.News;

public class SessionTest {

    SessionFactory sessionFactory;
    Session session;
    Transaction transaction;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        @SuppressWarnings("deprecation")
        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();
    }

    /**
     * Work 接口: 直接通过 JDBC API 来访问数据库的操作
     */
    @Test
    public void testDoWork() {
        session.doWork(new Work() {

            @Override
            public void execute(Connection connection) throws SQLException {
                //调用存储过程. 
                System.out.println(connection);
            }
        });
    }

    /**
     * evict: 从 session 缓存中把指定的持久化对象移除
     */
    @Test
    public void testEvict() {
        News news1 = (News) session.get(News.class, 1);
        news1.setTitle("AA");
        session.evict(news1); 
    }

    /**
     * delete: 执行删除操作. 
     * 只要 OID 和数据表中一条记录对应, 就会准备执行 delete 操作; 若 OID 在数据表中没有对应的记录, 则抛出异常
     * 可以通过设置 hibernate 配置文件 hibernate.use_identifier_rollback 为 true, 使删除对象后, 把其 OID 置为  null
     */
    @Test
    public void testDelete() {
//      News news = new News();
//      news.setId(2);

        News news = (News) session.get(News.class, 15);
        session.delete(news);
        System.out.println(news);
    }

    /**
     * 同时包含了 save() 与 update() 方法的功能
     * 注意：
     * 使用 hibernate 的自动生成id
     *  1. 若 OID 不为 null, 但数据表中还没有和其对应的记录. 会抛出一个异常. 
     *  2. 了解: OID 值等于 id 的 unsaved-value 属性值的对象, 也被认为是一个游离对象
     */
    @Test
    public void testSaveOrUpdate() {
        News news = new News("F的FF", "fff", new Date());
        //news.setId(11);

        session.saveOrUpdate(news); 
    }

    /**
     * update：
     * 1. 若更新一个持久化对象，不需要显式的调用 update 方法，以为在调用 Transaction 的 commit 方法时，会先调用 flush 方法
     * 2. 更新一个游离对象, 需要显式的调用 session 的 update 方法. 可以把一个游离对象变为持久化对象
     * 
     * 注意：
     *  1. 无论要更新的游离对象和数据库表中的对象是否一致，都会发送一个 UPDATE 语句。如何能让 update 方法不再盲目的触发 update 语句？
     *  在 .hbm.xml 文件的 class 节点设置select-before-update=true (默认为 false). 但通常不需要设置该属性.（一般不设置）
     *  2. 若数据表中没有对应的记录, 但还调用了 update 方法, 会抛出异常（不是游离对象）
     *  3. 当 update() 方法关联一个游离对象时,如果在 Session 的缓存中已经存在相同 OID 的持久化对象, 会抛出异常. 
     *  因为在 Session 缓存中不能有两个 OID 相同的对象!
     */
    @Test
    public void testUpdate() {
        News news = (News) session.get(News.class, 1);

        transaction.commit();
        session.close();

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();

        news.setAuthor("lina");
        //news.setId(3);

        //News news2 = (News) session.get(News.class, 1);
        session.update(news);
    }

    /**
     * get VS 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, 1);
        System.out.println(news.getClass().getName());
        //System.out.println(news);
        session.close();
        System.out.println(news);
    }

    @Test
    public void testGet() {
        News news = (News) session.get(News.class, 1);
        session.close();
        System.out.println(news);
    }

    /**
     * persist：也会执行 INSERT 操作
     * 和 save 方法的区别：在调用 persist 方法之前, 若对象已经有 id 了, 则不会执行 INSERT, 而抛出异常
     *                在调用 persist 方法之后设置对象 id，也会抛出异常
     */
    @Test
    public void testPersist() {
        News news = new News("BB", "bb", new Date());
        //news.setId(201);//不好使， 抛出异常
        System.out.println(news);
        session.persist(news);
    }

    /**
     * 1. save() 方法
     * 1). 使一个临时对象变为持久化对象
     * 2). 为对象分配 ID.
     * 3). 在 flush 缓存时会发送一条 INSERT 语句.
     * 4). 在 save 方法之前的 id 是无效的
     * 5). 持久化对象的 ID 是不能被修改的!
     */
    @Test
    public void testSave() {
        News news = new News("AA", "aa", new Date());
        news.setId(100);//不好使
        System.out.println(news);
        session.save(news);
        System.out.println(news);

        news.setId(100);//不好使，抛出异常
    }

    /**
     * clear(): 清理缓存
     */
    @Test
    public void testClear() {
        News news1 = (News) session.get(News.class, 1);
        System.out.println(news1);

        session.clear();

        News news2 = (News) session.get(News.class, 1);
        System.out.println(news2);
    }

    /**
     * refresh：会强制发送 select 语句，已使 session 缓存中的记录和数据库中的数据一致
     * 注意：发送请求可能获取的数据不是最新的（事务的隔离级别）
     */
    @Test
    public void testRefresh() {
        News news1 = (News) session.get(News.class, 1);
        System.out.println(news1);

        // 需要设置 hibernate 事务的隔离级别 
        session.refresh(news1);
        System.out.println(news1);
    }

    /**
     * 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 是存在的!)
     *           若记录的 ID 不是由底层数据库自增的方式生产，则在调用save() 方法是，不会马上发送 INSERT 语句
     */
    @Test
    public void testSessionFlush2(){
        News news = new News("Java", "SUN", new Date());
        session.save(news);
    }

    @Test
    public void testSessionFlush() {
        News news = (News) session.get(News.class, 1);
        news.setAuthor("lina");
        System.out.println(news);

        //session.flush();

        News news2 = (News) session.createCriteria(News.class).uniqueResult();
        System.out.println(news2);
    }

    /**
     * 测试 session 缓存：
     * Session 缓存可减少 Hibernate 应用程序访问数据库的频率，只发送一条查询语句
     * 只要 Session 实例没有结束生命周期, 且没有清理缓存，则存放在它缓存中的对象也不会结束生命周期
     */
    @Test
    public void testSessionCache() {
        News news = (News) session.get(News.class, 1);
        System.out.println(news);

        News news1 = (News) session.get(News.class, 1);
        System.out.println(news1);

        System.out.println(news == news1);
    }
}

Hibernate 与触发器协同工作

Hibernate 与数据库中的触发器协同工作时, 会造成两类问题
触发器使 Session 的缓存中的持久化对象与数据库中对应的数据不一致:触发器运行在数据库中, 它执行的操作对 Session 是透明的
Session 的 update() 方法盲目地激发触发器: 无论游离对象的属性是否发生变化, 都会执行 update 语句, 而 update 语句会激发数据库中相应的触发器
解决方案:
在执行完 Session 的相关操作后, 立即调用 Session 的 flush() 和 refresh() 方法, 迫使 Session 的缓存与数据库同步(refresh() 方法重新从数据库中加载对象)

在映射文件的的 <\class> 元素中设置 select-before-update 属性: 当 Session 的 update 或 saveOrUpdate() 方法更新一个游离对象时, 会先执行 Select 语句, 获得当前游离对象在数据库中的最新数据, 只有在不一致的情况下才会执行 update 语句