一、Hibernate对事务的并发处理
事务的四个特性:ACID,原子性、一致性、隔离性、持久性。
1、隔离性引发问题: 脏读、不可重复读、虚读 、丢失更新 (lost update)
* 脏读 : 一个事务 读取 另一个事务 未提交的数据
* 不可重复读: 一个事务中 连续读取 两次, 第二次读取另一个事务 已经提交 update修改数据 (数据改变)
* 虚读 : 一个事务 读取 另一个事务 已经提交 插入数据 (记录条数改变)
* 丢失更新 : 两个事务同时修改数据,后提交事务覆盖了先提交事务的结果
2、数据库为了解决事务的隔离性问题,提供四种隔离级别(不是所有数据库都支持这四种级别)
* READ_UNCOMMITED : 读取未提交,引发所有隔离问题
* READ_COMMITTED : 读已提交,阻止脏读,发生不可重复读和虚读
* REPEATABLE_READ : 重复读 ,阻止脏读、不可重复读,发生虚读
* SERIALIZABLE : 串行处理,不允许两个事务 同时操作一个目标数据,根本不存在并发,不存在并发问题 (效率低下)
** 企业开发中主要 READ_COMMITTED (Oracle默认级别)、REPEATABLE_READ (MySQL默认级别)
设置hibernate事务隔离级别
hibernate.connection.isolation = 4
1—Read uncommitted isolation
2—Read committed isolation
4—Repeatable read isolation
8—Serializable isolation
例如 :
<!-- 使用 read committed 级别 -->
<property name="hibernate.connection.isolation">2</property>
3、丢失更新如何解决?
两种方法:悲观锁和乐观锁。
悲观锁:采用数据库内部锁机制,在一个事务操作数据库时,为数据加锁,另一个事务无法操作。
*排它锁(写锁),数据库中每张表只能添加一个排它锁,排它锁与其它锁互斥。
*在修改数据时,自动添加排它锁。
*在查询数据时,添加排它锁 select * from customers for update;
hibernate中使用悲观锁
Customer customer = (Customer) session.load(Customer.class, 1,LockMode.UPGRADE); // MySQL
Customer customer = (Customer) session.load(Customer.class, 1,LockMode.UPGRADE);
* 悲观锁解决丢失更新,效率问题 , 数据不能同时修改
乐观锁:
与数据库锁无关,在数据表中为数据添加 版本字段,每次数据修改都会导致版本号+1
乐观锁原理:
Hibernate使用乐观锁步骤:
hibernate 为Customer表 添加版本字段
1) 在customer类 添加 private Integer version; 版本字段
2) 在Customer.hbm.xml 定义版本字段
<!-- 定义版本字段 -->
<!-- name是属性名 -->
<version name="version"></version>
二、管理Session
1、 hibernate 提供三种管理Session的方式
* Session 对象的生命周期与本地线程绑定 (与ThreadLocal绑定)
* Session 对象的生命周期与 JTA 事务绑定 (分布式事务管理)
* Hibernate 委托程序管理 Session 对象的生命周期
会在程序中获得Session对象,使用Session, 需要手动session.close()
在hibernate配置文件中 配置 hibernate.current_session_context_class 值 thread (使Session与线程绑定)
2、步骤
1) 配置hibernate.cfg.xml
<!-- 配置session 与线程绑定 -->
<property name="hibernate.current_session_context_class">thread</property>
2) 在程序中通过sessionFactory.getCurrentSession() 获得线程绑定Session对象
注意: 使用 getCurrentSession 获得与线程绑定Session对象时,在事务关闭时,Session对象也会close
三、二级缓存
1、 缓存好处: 将数据库或者硬盘数据 ,保存在内存中,减少数据库查询次数,减少硬盘交互,提高检索效率
2、 hibernate的二级缓存
hibernate 共有两个级别的缓存
* 一级缓存 ,保存Session中, 事务范围的缓存
* 二级缓存 ,保存SessionFactory , 进程范围的缓存
SessionFacoty 两部分缓存
内置 : (Hibernate自带的,不可卸载)hbm文件配置, 命名查询SQL语句
外置 : (一个可配置的缓存插件)二级缓存,必须引入第三方缓存插件 才能使用
3、二级缓存内部结构学习
* 类缓存区域
* 集合缓存区域
* 更新时间戳区域
* 查询缓存区域
4、二级缓存并发策略
transactional : 提供Repeatable Read事务隔离级别 ,缓存支持事务,发生异常的时候,缓存也能够回滚
read-write : 提供Read Committed事务隔离级别, 更新缓存的时候会锁定缓存中的数据
nonstrict-read-write : 导致脏读, 很少使用
read-only: 数据不允许修改 ,只能查询
* 很少被修改,不是很重要,允许偶尔的并发问题, 放入二级缓存考虑因素(二级缓存 监控,是否采用二级缓存主要参考指标)
5、hibernate 支持二级缓存技术
* EHCache (主要学习,支持本地缓存,支持分布式缓存)
* OSCache
* SwarmCache
* JBossCache
6、 二级缓存的配置
1)导入第三方缓存技术jar包
ehcache-1.5.0.jar
依赖 backport-util-concurrent 和 commons-logging
2)在hibernate.cfg.xml 开启二级缓存
<property name="hibernate.cache.use_second_level_cache">true</property>
3)配置二级缓存技术的提供商
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
4)配置缓存数据对象并发策略
使用read-write 并发策略
方式一 在hbm文件配置
<class name="lsq.hibernate.domain.Customer" table="customers" catalog="hibernate3day4" >
<!-- 类级别缓存 -->
<cache usage="read-write"/>
<set name="orders" cascade="all-delete-orphan" inverse="true" >
<!-- 关联集合级别缓存 -->
<cache usage="read-write"/>
</set>
</class>
方式二 在cfg文件配置 (集中配置)
<!-- 类级别缓存 -->
<class-cache usage="read-write" class="lsq.hibernate.domain.Customer"/>
<class-cache usage="read-write" class="lsq.hibernate.domain.Order"/>
<!-- 集合缓存 -->
<collection-cache usage="read-write" collection="lsq.hibernate.domain.Customer.orders"/>
5)在src中 配置 ehcache.xml
将 ehcache-1.5.0 jar包中 ehcache-failsafe.xml 改名 ehcache.xml 放入 src
案例:证明二级缓存存在
package lsq.hibernate.secondcache;
import lsq.hibernate.domain.Customer;
import lsq.hibernate.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
public class HibernateTest2 {
@Test
//证明二级缓存存在
public void demo1(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//把查询结果放入一级缓存、二级缓存
Customer customer1 = (Customer) session.get(Customer.class, 1);
System.out.println(customer1);
Customer customer2 = (Customer) session.get(Customer.class,1);//读取一级缓存查询
System.out.println(customer2);
transaction.commit();//事务提交,自动关闭Session,一级缓存就没有了
session = HibernateUtils.getCurrentSession();//重新获取session,开启事务
transaction = session.beginTransaction();
Customer customer3 = (Customer) session.get(Customer.class, 1);//查找二级缓存
System.out.println(customer3);
transaction.commit();//自动关闭Session
}
}
控制台结果:
如果在核心配置文件中把二级缓存的开启由true变为false,结果:
7、类缓存区数据存储特点
* 从二级缓存区返回数据每次的地址都是不同的 (散装数据 )
每次查询二级缓存,都是将散装数据 构造为一个新的对象
将上个案例代码进行修改:
package lsq.hibernate.secondcache;
import lsq.hibernate.domain.Customer;
import lsq.hibernate.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
public class HibernateTest2 {
@Test
//证明二级缓存存在
public void demo1(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//把查询结果放入一级缓存、二级缓存
Customer customer1 = (Customer) session.get(Customer.class, 1);
System.out.println(customer1);
Customer customer2 = (Customer) session.get(Customer.class,1);//读取一级缓存查询
System.out.println(customer2);
transaction.commit();//事务提交,自动关闭Session,一级缓存就没有了
session = HibernateUtils.getCurrentSession();//重新获取session,开启事务
transaction = session.beginTransaction();
Customer customer3 = (Customer) session.get(Customer.class, 1);//查找二级缓存
System.out.println(customer3);
transaction.commit();//自动关闭Session
session = HibernateUtils.getCurrentSession();//重新获取session,开启事务
transaction = session.beginTransaction();
Customer customer4 = (Customer) session.get(Customer.class, 1);//查找二级缓存
System.out.println(customer4);
transaction.commit();//自动关闭Session
}
}
测试结果:
发现:从一级缓存获取的对象内存地址是相同的,而从二级缓存获取的对象的地址是不同的。
二级缓存类缓存区域原理:
*☆:get、load方法都可以读取二级缓存的数据,Query的list方法只能存,不能取。
8、集合缓存区特点
注释掉 <class-cache usage="read-write" class="lsq.hibernate.domain.Order"/> Order 类缓存
orders 集合无法缓存
* 集合缓存区 数据缓存 依赖 类缓存区 数据缓存
原理:
☆:一级缓存的操作 会同步到二级缓存
9、当内存中数据过多时,需要将数据缓存到硬盘
配置src/ehcache.xml
* <diskStore path="java.io.tmpdir"/> 配置二级缓存硬盘临时目录位置
* <defaultCache <!-- 缓存属性配置 -->
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
maxElementsOnDisk="10000000"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU"
/>
defaultCache , 是默认配置,该属性 对所有缓存数据 都有效
<cache name="lsq.hibernate.domain.Customer" // 自定义配置,该属性对cn.itcast.domain.Customer类缓存有效
maxElementsInMemory="10000" // 内存中最大对象数量 ,超过数量,数据会被缓存到硬盘
eternal="false" // 是否缓存为永久性 false 不永久
timeToIdleSeconds="120" // 闲置时间,超过时间回收
timeToLiveSeconds="120" // 存活时间,对象不管是否使用,到了时间回收
overflowToDisk="true" // 是否可以缓存到硬盘
maxElementsOnDisk="10000000" // 硬盘缓存最大对象数量
diskPersistent="false" // 当jvm结束时是否持久化对象 true false 默认是false
diskExpiryThreadIntervalSeconds="120" // 指定专门用于清除过期对象的监听线程的轮询时间
memoryStoreEvictionPolicy="LRU"
/>
10、更新时间戳区域的作用
作用:记录数据最后更新的时间,确保缓存数据是有效的。
更新时间戳区域,记录数据最后更新时间,在使用二级缓存时,比较缓存时间t1与更新时间t2,如果t2>t1,丢弃原来缓存数据,重新查询,然后再缓存。
更新时间戳区域原理图:
11、Query的iterate方法
同list()一样,也能执行查询操作
Query的iterate 方法返回 只有OID 代理对象
* 产生查询 id 的SQL 语句 select id from orders;
访问每个Order 具体数据时,再生成SQL 查询 ---- > N+1查询
***** batch-size 无法优化,使用 二级缓存优化 ,iterate方法需要和二级缓存结合在一起是否,否则效率会很差。
四、查询缓存
有人称查询缓存为Hibernate的第三级缓存。
*二级缓存缓存的数据都是类对象数据,数据都是缓存在“类缓存区域”。
二级缓存缓存的PO类对象,条件(key)是id.
但是,如果查询条件不是id查询,缓存数据不是PO类完整对象,那么这时候就不适合使用二级缓存。
缓存查询:缓存查询数据结果,key是查询生成的SQL语句,查询缓存比二级缓存功能更强大。
配置查询缓存的步骤:
1、配置二级缓存
2、在hibernate.cfg.xml中启用查询缓存
3、必须在程序中指定使用查询缓存
查询缓存案例:
@Test
// 有些情况必须使用 查询缓存
public void demo8() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 查询1号客户 的姓名
Query query = session
.createQuery("select name from Customer where id =1 ");
// 启用查询缓存
query.setCacheable(true); // 放入查询缓存
String name = (String) query.uniqueResult();
System.out.println(name);
transaction.commit();// 自动关闭Session
session = HibernateUtils.getCurrentSession();
transaction = session.beginTransaction();
// 查询1号客户 的姓名
Query query2 = session
.createQuery("select name from Customer where id =1 ");
// 启用查询缓存
query2.setCacheable(true);// 从查询缓存进行查询
String name2 = (String) query2.uniqueResult();
System.out.println(name2);
transaction.commit();// 自动关闭Session
}
五、二级缓存性能监控
没有监测和性能参数而进行优化是毫无意义的。Hibernate为其内部操作提供了一系列的示意图,因此可以从每个SessionFactory抓取其统计数据。
SessionFactory提供二级缓存监控方法,用来获取二级缓存命中次数。
* Statistics getStatistics() 返回 Statistics 对象
Statistics 对象提供
* long getQueryCacheHitCount() 获取查询缓存命中次数
* long getQueryCacheMissCount() 获取查询缓存丢失次数
* long getSecondLevelCacheHitCount() 获取二级缓存命中次数
* long getSecondLevelCacheMissCount() 获取二级缓存丢失次数
二级缓存监控需要在hibernate.cfg.xml中设置属性
* 在配置期间,将 hibernate.generate_statistics设置为 true或 false
hitCount/(hitCount + missCount) = 命中率
☆:查询二级缓存后,如果找到 hitCount +1 ,如果没找到 missCount+1 , 如果一级缓存找到了,就不会去查找二级缓存, hitCount、missCount 不变
六、继承关系映射
Hibernate 允许 将继承关系保存到 数据库中
1、 三种继承映射策略
第一种 subclass 父类和子类数据用同一张表保存,引入辨别者列,区分数据是父类数据还是子类数据
第二种 join-subclass 父类和子类 数据都是单独一张表,表之间通过外键 表示继承关系
第三种 unions-subclass(了解 ) 父类和子类 都是单独一张表,表之间没有任何 联系
2、 subclass 元素的继承映射
父类数据 和 子类数据 存放一张表,引入一列 辨别者列(区分数据是否父类还是子类)
1) 编写 Employee、HourEmployee、SalaryEmployee
2) 在继承关系模型中,只需要对父类编写hbm映射就可以了
<hibernate-mapping>
<class name="lsq.hibernate.subclass.Employee" table="employee" catalog="hibernate3day4" discriminator-value="ee">
<id name="id">
<generator class="identity"></generator>
</id>
<!-- 定义辨别者列 -->
<!-- 该列主要给Hibernate框架使用 -->
<discriminator column="etype"></discriminator>
<property name="name"></property>
<!-- 每个子类 使用 subclass元素配置 -->
<subclass name="lsq.hibernate.subclass.HourEmployee" discriminator-value="he">
<property name="rate"></property>
</subclass>
<subclass name="lsq.hibernate.subclass.SalaryEmployee" discriminator-value="se">
<property name="salary"></property>
</subclass>
</class>
</hibernate-mapping>
测试添加和查询
3、 joined-subclass 元素的继承映射
为父类数据和子类数据分布建表,公共信息放入父类表,个性信息放入子类表,通过外键关联
*** 使用继承映射,类关系不变的
<hibernate-mapping>
<class name="lsq.hibernate.joinedsubclass.Employee" table="employee" catalog="hibernate3day4" >
<id name="id">
<generator class="identity"></generator>
</id>
<property name="name"></property>
<!-- 为每个子类表编写 joined-subclass 元素 -->
<joined-subclass name="lsq.hibernate.joinedsubclass.HourEmployee" table="h_employee">
<!-- 配置子类表 外键 -->
<!-- eid 是 子类表主键,同时也是外键,引入父类表 id -->
<key column="eid"></key>
<property name="rate"></property>
</joined-subclass>
<joined-subclass name="lsq.hibernate.joinedsubclass.SalaryEmployee" table="s_employee">
<key column="eid"></key>
<property name="salary"></property>
</joined-subclass>
</class>
</hibernate-mapping>
*** 优先使用 joined-subclass, 如果类信息非常少,也可以使用 subclass
七、集合映射
在一对多和多对多中,都使用了集合set。
* 使用Set集合,在hbm文件中 使用 <set> 配置 ,set集合是无序的,不允许重复
在实际开发中,经常会使用 有序的集合 List
在hbm中 使用 <bag> <list> <set>
Customer {
Set<Order> orders ; ------------> hbm <set> 不允许重复,无序
}
Customer {
List<Order> orders ; -----------> hbm <list> 允许重复,有序 <bag> 无序 ,允许重复
}
bag配置方法 (性能最好 ):
<hibernate-mapping>
<class name="lsq.hibernate.collectionmapping.Author" table="author">
<id name="id">
<generator class="identity"></generator>
</id>
<property name="name"></property>
<!-- 一对多 -->
<bag name="articles">
<key column="author_id"></key>
<one-to-many class="lsq.hibernate.collectionmapping.Article"/>
</bag>
</class>
</hibernate-mapping>
list 配置方法:
原理: 在数据表中 保存数据下标 (维护有序性 ),在数据库中多写一列,这一列来维护关联集合元素的顺序的。
<hibernate-mapping>
<class name="lsq.hibernate.collectionmapping.Author" table="author">
<id name="id">
<generator class="identity"></generator>
</id>
<property name="name"></property>
<list name="articles" cascade="all">
<key column="author_id"></key>
<!-- 生成列,article_index 维护顺序 -->
<list-index column="article_index"></list-index>
<one-to-many class="lsq.hibernate.collectionmapping.Article"/>
</list>
</class>
</hibernate-mapping>