一、概述
Session 是 Hibernate 向应用程序提供操纵数据的主要接口，它提供了基本的保存、更新、删除和加载 Java 对象的方法。
二、Session 缓存
1.简介
（1）Session 有一个缓存，称为 Hibernate 一级缓存。位于缓存中的对象称为持久化对象，每一个持久化对象与数据库中的一条记录对应。
（2）站在持久化的角度，Hibernate 将对象分为 4 种状态：临时状态、持久化状态、游离状态、删除状态。
2.测试 Session 缓存
（1）准备
①hibernate.cfg.xml 文件请参看上一篇文章。
②SessionFactory、Session、Transaction
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 destroy() {
transaction.commit();
session.close();
sessionFactory.close();
}
说明：使用单元测试类进行测试。因为是测试环境，不存在并发的情况，创建了一个 Session 对象。
（2）测试
@Test
public void testSession() {
News news = (News) session.get(News.class, 1);
System.out.println(news);
News news2 = (News) session.get(News.class, 1);
System.out.println(news2);
System.out.println(news.equals(news2));
}
测试结果：
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
News{id=1, title='Title', author='tom', date=2016-09-28}
News{id=1, title='Title', author='tom', date=2016-09-28}
true
说明：
第一次查询的时候，会将引用赋值给 news，同时向 Session 缓存中存入了一份。
第二次查询的时候，并没有发送 select 语句，而是从 Session 缓存中直接获取的。
3.操纵 Session 缓存
（1）flush() ：使数据表中的记录和 Session 缓存中的对象的状态保持一致。
① 在 Transaction 的 commit() 方法中，先调用 session 的 flush 方法，再提交事务。
org.hibernate.engine.transaction.spi.AbstractTransactionImpl#commit
@Override
public void commit() throws HibernateException {
if ( localStatus != LocalStatus.ACTIVE ) {
throw new TransactionException( "Transaction not successfully started" );
}
LOG.debug( "committing" );
beforeTransactionCommit();
try {
doCommit();
localStatus = LocalStatus.COMMITTED;
afterTransactionCompletion( Status.STATUS_COMMITTED );
}
catch ( Exception e ) {
localStatus = LocalStatus.FAILED_COMMIT;
afterTransactionCompletion( Status.STATUS_UNKNOWN );
throw new TransactionException( "commit failed", e );
}
finally {
invalidate();
afterAfterCompletion();
}
}
org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction#beforeTransactionCommit
protected void beforeTransactionCommit() {
this.transactionCoordinator().sendBeforeTransactionCompletionNotifications(this);
if(this.isDriver && !this.transactionCoordinator().getTransactionContext().isFlushModeNever()) {
this.transactionCoordinator().getTransactionContext().managedFlush();
}
if(this.isDriver) {
this.transactionCoordinator().getTransactionContext().beforeTransactionCompletion(this);
}
}
② 可能会打印 SQL 语句，但是不会提交事务。
③ 在未提交事务或显式的调用 flush() 方法前，也可能会进行 flush() 操作。
- 执行 HQL 或 QBC 查询，会先进行 flush() 操作，以得到数据表的最新记录。
- 若记录的 ID 是由数据库使用的自增的方式生成的，则在调用 save() 方法时，就会立即发送 INSERT 语句，因为 save 方法后，必须保证对象的 ID 存在。
（2）refresh()：会强制发送 SELECT 语句，以使 Session 缓存中对象的状态和数据表中对应的记录保持一致。
1 @Test
2 public void testRefresh() {
3 News news = (News) session.get(News.class, 1);
4 System.out.println(news);
5 session.refresh(news);
6 System.out.println(news);
7 }
我在第5行断点，然后修改数据库中 News 的 `author` 字段，改为 jerry。执行。
两次打印结果相同。
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
News{id=1, title='Title', author='tom', date=2016-09-28}
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
News{id=1, title='Title', author='tom', date=2016-09-28}
原因：数据库的隔离级别，Mysql 默认隔离级别为 REPEATABLE READ。
在 Hibernate 的配置文件中可以显式的设置隔离级别. 每一个隔离级别都对应一个整数:
1. READ UNCOMMITED
2. READ COMMITED
4. REPEATABLE READ
8. SERIALIZEABLE
Hibernate 通过为 Hibernate 映射文件指定 hibernate.connection.isolation 属性来设置事务的隔离级别。
修改后的打印结果：
两次打印结果不同。
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
News{id=1, title='Title', author='jerry', date=2016-09-28}
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
News{id=1, title='Title', author='tom', date=2016-09-28}
（3）clear()：清理缓存。
@Test
public void testClear() {
session.get(News.class, 1);
session.clear();
session.get(News.class, 1);
}
输出结果：
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
Hibernate:
select
news0_.id as id1_0_0_,
news0_.title as title2_0_0_,
news0_.author as author3_0_0_,
news0_.date as date4_0_0_
from
hibernate.news news0_
where
news0_.id=?
三、Session API
1.四种状态的转换图
（1）临时对象
- 在使用代理主键的情况下，OID 通常为 null
- 不处于 Session 的缓存中
- 在数据库中没有对应的记录
（2）持久化对象
- OID 不为空
- 位于 Session 缓存中
- 在同一个 Session 实例的缓存中，数据库表中的每条记录只对应唯一的持久化对象
（3）游离对象
- OID 不为空
- 不处于 Session 缓存中
（4）删除对象
- 在数据库中没有和其 OID 对应的记录
- 不再处于 Session 缓存中
2.save()
（1）将一个临时对象转变为持久化对象
（2）为对象分配 ID
（3）在 flush 缓存的时候，计划执行一条 INSERT 语句
（4）在 save() 方法前的 id 是无效的
（5）持久化对象的 ID 是不能被更改的。因为 Hibernate 通过持久化对象的 OID 来维持它与数据库相关记录的对应关系。
* persist() 和 save() 区别
对一个 OID 不为 Null 的对象执行 save() 方法时，会把该对象以一个新的 OID 保存到数据库中，而 persist() 则会抛出一个异常。
3.get()/load()
（1）都可以根据 OID 从数据库中加载一个持久化对象。
（2）执行 get() 时会立即加载对象。执行 load() ，若不使用该对象，则不会立即执行查询操作，而是返回一个代理对象。
（3）get() 是立即检索，而 load() 是延迟检索。
（4）若数据表中没有对应记录，Session 也没有被关闭。get() 返回 null，load() 使用返回对象时抛出异常。
（5）load() 可能会抛出 LozyInitizationException 异常：在需要初始化代理对象之前已经关闭了 Session。
@Test
public void testLoad() {
News news = (News) session.load(News.class, 1);
session.close();
System.out.println(news);
}
org.hibernate.LazyInitializationException: could not initialize proxy - no Session
4.update()
（1）将一个游离对象转变为持久化对象，并且计划执行一条 update 语句。
（2）若更新一个持久化对象，不需要显式的调用 update() 方法。因为在调用 Transaction 的 commit() 方法时，会先执行 session 的 flush() 方法。
（3）注意
- 无论要更新的游离对象和数据表的记录是否一致，都会发送 UPADATE 语句。如何让只在不一致的情况下发送 UPDATE 语句？在 entity.hbm.xml 文件的 class 节点设置 select-before-update=true（默认为 false）。通常不需要设置，与触发器协同工作时需要注意。
- 若数据表中没有对应的记录，但还是调用了 update() 方法，会抛出异常。
- 当 update() 方法关联一个游离对象时，如果在 Session 缓存中已经存在相同 OID 的持久化对象，会抛出异常。因为在 Session 缓存中不能有两个 OID 相同的对象。
5.saveOrUpdate()
（1）同时包含了 save() 和 update() 方法的功能。
（2）判断是否是游离对象还是临时对象是根据 对象的 OID 来判定的。若为 null ，则执行 save() ，若不为 null，则判定为游离对象，执行 update() 。
（3）若 OID 不为 null，但数据中还没有与之对应的记录，则会抛出一个异常。
（4）了解：OID 值等于 id 的 unsaved-value 属性值的对象，也被认为是一个游离对象。
6.delete()
（1）既可以删除一个游离对象，也可以删除一个持久化对象。
（2）只要 OID 和数据表中一条记录对应，就会准备执行 delete 操作，若 OID 在数据表中没有对应的记录，则抛出异常。
（3）在执行 delete() 后，还是可以获取到对象的 OID，防止对该对象的其他持久化操作，可以通过设置 hibernate 配置文件的 hibernate.use_identifier_rollback 为 true，
使删除对象后，把其 OID 值为 null。
7.evict()
把指定持久化对象从 session 缓存中移除。
8.调用存储过程
@Test
public void testWork() {
session.doWork(new Work() {
@Override
public void execute(Connection connection) throws SQLException {
System.out.println(connection);
// 调用存储过程
}
});
}
四、总结
介绍了 Hibernate 的一级缓存，包括如何操纵 Session 的缓存，以及四种状态之间的转换，以及建立在 Session 缓存和四种状态基础上的 Session API。