hibernate4
第23课 性能优化策略
1、 注意session.clear()的动用，尤其在不断分页循环的时候
a) 在一个大集合中进行遍历，遍历msg,取出其中的含有敏感字样的对象
b) 另外一种形式的内存泄露 //面试是：Java有内存泄漏吗？
2、 1 + N问题 //典型的面试题
a) Lazy
b) BatchSize 设置在实体类的前面
c) joinfetch
3、 list 和 iterate不同之处
a) list取所有
b) Iterate先取ID，等用到的时候再根据ID来取对象
c) session中list第二次发出，仍会到数据库查询
d) iterate第二次，首先找session级缓存
第24课 hibernate缓存
一、 Session级缓存(一级缓存)
一级缓存很短和session的生命周期一致，因此也叫session级缓存或事务级缓存
hibernate一级缓存
那些方法支持一级缓存：
* get()
* load()
* iterate（查询实体对象）
如何管理一级缓存：
* session.clear(),session.evict()
如何避免一次性大量的实体数据入库导致内存溢出
* 先flush，再clear
如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具
二、 二级缓存
Hibernate默认的二级缓存是开启的。
二级缓存也称为进程级的缓存，也可称为SessionFactory级的缓存(因为SessionFactory可以管理二级缓存)，它与session级缓存不一样，一级缓存只要session关闭缓存就不存在了。而二级缓存则只要进程在二级缓存就可用。
二级缓存可以被所有的session共享
二级缓存的生命周期和SessionFactory的生命周期一样，SessionFactory可以管理二级缓存
二级缓存同session级缓存一样，只缓存实体对象，普通属性的查询不会缓存
二级缓存一般使用第三方的产品，如EHCache
1、 二级缓存的配置和使用：
配置二级缓存的配置文件：模板文件位于hibernate\etc目录下(如ehcache.xml)，将模板存放在ClassPath目录中，一般放在根目录下(src目录下)
<ehcache>
<!--设置当缓存对象益出时，对象保存到磁盘时的保存路径。
如 d:\xxxx
The following properties aretranslated:
user.home - User's home directory
user.dir - User's current workingdirectory
java.io.tmpdir - windows的临时目录 -->
<diskStore path="java.io.tmpdir"/>
<!--默认配置/或对某一个类进行管理
maxInMemory - 缓存中可以存入的最多个对象数
eternal - true:表示永不失效，false：不是永久有效的。
timeToIdleSeconds - 空闲时间，当第一次访问后在空闲时间内没有访问，则对象失效，单位为秒
timeToLiveSeconds - 被缓存的对象有效的生命时间，单位为秒
overflowToDisk 当缓存中对象数超过核定数(益出时)时，对象是否保存到磁盘上。true:保存；false：不保存
如果保存，则保存路径在标签<diskStore>中属性path指定
-->
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
/>
</ehcache>
2、 二级缓存的开启：
Hibernate中二级缓存默认就是开启的，也可以显示的开启
二级缓存是hibernate的配置文件设置如下：
<!--开启二级缓存，hibernate默认的二级缓存就是开启的 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
3、 指定二级缓存产品提供商：
修改hibernate的 配置文件，指定二级缓存提供商，如下：
<!--指定二级缓存提供商-->
<property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
以下为常见缓存提供商：
| Cache |
Provider class |
Type |
Cluster Safe |
Query Cache Supported |
| Hashtable (not intended for production use) |
org.hibernate.cache.HashtableCacheProvider |
memory |
|
yes |
| EHCache |
org.hibernate.cache.EhCacheProvider |
memory, disk |
|
yes |
| OSCache |
org.hibernate.cache.OSCacheProvider |
memory, disk |
|
yes |
| SwarmCache |
org.hibernate.cache.SwarmCacheProvider |
clustered (ip multicast) |
yes (clustered invalidation) |
|
| JBoss TreeCache |
org.hibernate.cache.TreeCacheProvider |
clustered (ip multicast), transactional |
yes (replication) |
yes (clock sync req.) |
4、 使用二级缓存
a) xml方式：指定哪些实体类使用二级缓存：
方法一：在实体类映射文件中，使用<cache>来指定那个实体类使用二级缓存，如下：
<cache
usage="transactional|read-write|nonstrict-read-write|read-only" (1)
region="RegionName" (2)
include="all|non-lazy" (3)
/>
(1) usage(必须)说明了缓存的策略: transactional、 read-write、nonstrict-read-write或read-only。
(2) region (可选, 默认为类或者集合的名字(class orcollection role name)) 指定第二级缓存的区域名(name of the secondlevel cache region)
(3) include (可选,默认为 all) non-lazy 当属性级延迟抓取打开时, 标记为lazy="true"的实体的属性可能无法被缓存
另外(首选?), 你可以在hibernate.cfg.xml中指定<class-cache>和 <collection-cache> 元素。
这里的usage 属性指明了缓存并发策略（cache concurrency strategy）。
策略：只读缓存（Strategy:read only）
如果你的应用程序只需读取一个持久化类的实例，而无需对其修改， 那么就可以对其进行只读 缓存。这是最简单，也是实用性最好的方法。甚至在集群中，它也能完美地运作。
<class name="eg.Immutable" mutable="false">
<cache usage="read-only"/>
....
</class>
策略:读/写缓存（Strategy:read/write）
如果应用程序需要更新数据，那么使用读/写缓存 比较合适。 如果应用程序要求“序列化事务”的隔离级别（serializable transaction isolation level），那么就决不能使用这种缓存策略。 如果在JTA环境中使用缓存，你必须指定hibernate.transaction.manager_lookup_class属性的值， 通过它，Hibernate才能知道该应用程序中JTA的TransactionManager的具体策略。 在其它环境中，你必须保证在Session.close()、或Session.disconnect()调用前， 整个事务已经结束。 如果你想在集群环境中使用此策略，你必须保证底层的缓存实现支持锁定(locking)。Hibernate内置的缓存策略并不支持锁定功能。
<class name="eg.Cat" .... >
<cache usage="read-write"/>
....
<set name="kittens" ... >
<cache usage="read-write"/>
....
</set>
</class>
策略:非严格读/写缓存（Strategy: nonstrictread/write）
如果应用程序只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离，那么比较适合使用非严格读/写缓存策略。如果在JTA环境中使用该策略，你必须为其指定hibernate.transaction.manager_lookup_class属性的值， 在其它环境中，你必须保证在Session.close()、或Session.disconnect()调用前， 整个事务已经结束。
策略:事务缓存（transactional）
Hibernate的事务缓存策略提供了全事务的缓存支持， 例如对JBoss TreeCache的支持。这样的缓存只能用于JTA环境中，你必须指定为其hibernate.transaction.manager_lookup_class属性。
没有一种缓存提供商能够支持上列的所有缓存并发策略。下表中列出了各种提供器、及其各自适用的并发策略。
表 19.2. 各种缓存提供商对缓存并发策略的支持情况（Cache Concurrency Strategy Support）
| Cache |
read-only |
nonstrict-read-write |
read-write |
transactional |
| Hashtable (not intended for production use) |
yes |
yes |
yes |
|
| EHCache |
yes |
yes |
yes |
|
| OSCache |
yes |
yes |
yes |
|
| SwarmCache |
yes |
yes |
|
|
| JBoss TreeCache |
yes |
|
|
yes |
注：此方法要求：必须要标签<cache>放在<id>标签之前
<class name="com.wjt276.hibernate.Student"table="t_student">
<!-- 指定实体类使用二级缓存 -->
<cache usage="read-only"/>//***********
<id name="id"column="id">
<generator class="native"/>
</id>
<property name="name"column="name"/>
<!--
使用多对一标签映射 一对多双向，下列的column值必需与多的一端的key字段值一样。
-->
<many-to-one name="classes"column="classesid"/>
</class>
方法二：在hibernate配置文件(hibernate.cfg.xml)使用<class-cache>标签中指定
要求：<class-cache>标签必须放在<maping>标签之后。
<hibernate-configuration>
<session-factory>
…………
<mapping resource="com/wjt276/hibernate/Classes.hbm.xml"/>
<mapping resource="com/wjt276/hibernate/Student.hbm.xml"/>
<class-cache class="com.wjt276.hibernate.Student"usage="read-only"/>
</session-factory>
</hibernate-configuration>
一般推荐使用方法一。
b) annotation注解
为了优化数据库访问,你可以激活所谓的Hibernate二级缓存.该缓存是可以按每个实体和集合进行配置的.
@org.hibernate.annotations.Cache定义了缓存策略及给定的二级缓存的范围. 此注解适用于根实体(非子实体),还有集合.
@Entity
@Cache(usage= CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
publicclass Forest { ... }
@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
@JoinColumn(name="CUST_ID")
@Cache(usage =CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public SortedSet<Ticket> getTickets(){
return tickets;
}
@Cache(
CacheConcurrencyStrategy usage(); (1)
String region() default ""; (2)
String include() default"all"; (3)
)
| (1) |
usage: 给定缓存的并发策略(NONE, READ_ONLY, NONSTRICT_READ_WRITE, READ_WRITE, TRANSACTIONAL) |
| (2) |
region (可选的)：缓存范围(默认为类的全限定类名或是集合的全限定角色名) |
| (3) |
include (可选的)：值为all时包括了所有的属性(proterty), 为non-lazy时仅含非延迟属性(默认值为all) |
5、 应用范围
没有变化，近似于静态的数据。
6、 二级缓存的管理：
1、 清除指定实体类的所有数据
SessionFactory.evict(Student.class);
2、 清除指定实体类的指定对象
SessionFactory.evict(Student.class, 1);//第二个参数是指定对象的ID，就可以清除指定ID的对象
使用SessionFactory清除二级缓存
Sessionsession = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Student student = (Student)session.load(Student.class, 1);
System.out.println("student.name=" +student.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
//管理二级缓存
SessionFactory factory = HibernateUtils.getSessionFactory();
//factory.evict(Student.class);
factory.evict(Student.class, 1);
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//会发出查询sql，因为二级缓存中的数据被清除了
Student student = (Student)session.load(Student.class, 1);
System.out.println("student.name=" +student.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
7、 二级缓存的交互
Sessionsession = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//仅向二级缓存读数据，而不向二级缓存写数据
session.setCacheMode(CacheMode.GET);
Student student =(Student)session.load(Student.class, 1);
System.out.println("student.name=" +student.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据
Student student =(Student)session.load(Student.class, 1);
System.out.println("student.name=" +student.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//只向二级缓存写数据，而不从二级缓存读数据
session.setCacheMode(CacheMode.PUT);
//会发出查询sql，因为session将CacheMode设置成了PUT
Student student = (Student)session.load(Student.class, 1);
System.out.println("student.name=" +student.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
CacheMode参数用于控制具体的Session如何与二级缓存进行交互。
· CacheMode.NORMAL - 从二级缓存中读、写数据。
· CacheMode.GET - 从二级缓存中读取数据，仅在数据更新时对二级缓存写数据。
· CacheMode.PUT - 仅向二级缓存写数据，但不从二级缓存中读数据。
· CacheMode.REFRESH - 仅向二级缓存写数据，但不从二级缓存中读数据。通过hibernate.cache.use_minimal_puts的设置，强制二级缓存从数据库中读取数据，刷新缓存内容。
如若需要查看二级缓存或查询缓存区域的内容，你可以使用统计（Statistics） API。
Map cacheEntries = sessionFactory.getStatistics()
.getSecondLevelCacheStatistics(regionName)
.getEntries();
此时，你必须手工打开统计选项。可选的，你可以让Hibernate更人工可读的方式维护缓存内容。
hibernate.generate_statistics true
hibernate.cache.use_structured_entries true
8、 总结
load默认使用二级缓存，iterate默认使用二级缓存
list默认向二级缓存中加数据，但是查询时候不使用
三、 查询缓存
查询缓存，是用于缓存普通属性查询的，当查询实体时缓存实体ID。
默认情况下关闭，需要打开。查询缓存，对list/iterator这样的操作会起作用。
可以使用<property name=”hibernate.cache.use_query_cache”>true</property>来打开查询缓存，默认为关闭。
所谓查询缓存：即让hibernate缓存list、iterator、createQuery等方法的查询结果集。如果没有打开查询缓存，hibernate将只缓存load方法获得的单个持久化对象。
在打开了查询缓存之后，需要注意，调用query.list()操作之前，必须显式调用query.setCachable(true)来标识某个查询使用缓存。
查询缓存的生命周期：当前关联的表发生修改，那么查询缓存生命周期结束
注意查询缓存依赖于二级缓存，因为使用查询缓存需要打开二级缓存
查询缓存的配置和使用：
* 在hibernate.cfg.xml文件中启用查询缓存，如：
<propertyname="hibernate.cache.use_query_cache">true</property>
* 在程序中必须手动启用查询缓存，如：
query.setCacheable(true);
例如：
session= HibernateUtils.getSession();
session.beginTransaction();
Query query = session.createQuery("selects.name from Student s");
//启用查询查询缓存
query.setCacheable(true);
List names = query.list();
for (Iteratoriter=names.iterator();iter.hasNext(); ) {
String name =(String)iter.next();
System.out.println(name);
}
System.out.println("-------------------------------------");
query = session.createQuery("selects.name from Student s");
//启用查询查询缓存
query.setCacheable(true);
//没有发出查询sql，因为启用了查询缓存
names = query.list();
for (Iteratoriter=names.iterator();iter.hasNext(); ) {
String name =(String)iter.next();
System.out.println(name);
}
session.getTransaction().commit();
Session session = sf.openSession();
session.beginTransaction();
List<Category>categories = (List<Category>)session.createQuery("from Category")
.setCacheable(true).list();
session.getTransaction().commit();
session.close();
Session session2 = sf.openSession();
session2.beginTransaction();
List<Category> categories2= (List<Category>)session2.createQuery("from Category")
.setCacheable(true).list();
session2.getTransaction().commit();
session2.close();
注：查询缓存的生命周期与session无关。
查询缓存只对query.list()起作用，query.iterate不起作用，也就是query.iterate不使用
四、 缓存算法
1、 LRU、LFU、FIFO
———————————————————-----------------------------------------------------------------------------
解决1+N问题
- package com.demo.hibernate;
- import java.util.Date;
- import java.util.List;
- import javax.persistence.FetchType;
- import javax.persistence.ManyToOne;
- import org.hibernate.Criteria;
- import org.hibernate.Session;
- import org.hibernate.SessionFactory;
- import org.hibernate.annotations.BatchSize;
- import org.hibernate.cfg.AnnotationConfiguration;
- import org.hibernate.criterion.Example;
- import org.hibernate.criterion.Restrictions;
- import org.hibernate.tool.hbm2ddl.SchemaExport;
- import org.junit.AfterClass;
- import org.junit.BeforeClass;
- import org.junit.Test;
- public class HibernateTreeTest {
- private static SessionFactory sf = null;
- @BeforeClass
- public static void beforClass() {
- // new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- try {
- sf = new AnnotationConfiguration().configure().buildSessionFactory();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @AfterClass
- public static void afterClass() {
- sf.close();
- }
- @Test
- public void testSchemaExport() { //生成建表语句
- new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- }
- @Test
- public void testSave() {
- Session session = sf.openSession();
- session.beginTransaction();
- // 存入10个板块
- for(int i=0; i<10; i++) {
- Category c = new Category();
- c.setName("c"+i);
- Topic t = new Topic();
- t.setCategory(c);
- t.setCreateDate(new Date());
- t.setTitle("t" + i);
- session.save(c);
- session.save(t);
- }
- session.getTransaction().commit();
- session.close();
- }
- //1+N 关联
- @Test
- public void testQuery1() {
- Session session = sf.openSession();
- session.beginTransaction();
- // List<Topic> topics = (List<Topic>)session.createCriteria(Topic.class).list(); //默认的已经处理了1+N
- List<Topic> topics = (List<Topic>)session.createQuery("from Topic").list();
- for(Topic t : topics) {
- System.out.println(t.getId() + "--" + t.getTitle());
- }
- session.getTransaction().commit();
- session.close();
- }
- //解决1+N 问题 第一种方法@ManyToOne(fetch=FetchType.LAZY)
- @Test
- public void testQuery2() {
- Session session = sf.openSession();
- session.beginTransaction();
- List<Topic> topics = (List<Topic>)session.createQuery("from Topic").list();
- for(Topic t : topics) {
- System.out.println(t.getId() + "--" + t.getTitle());
- System.out.println(t.getCategory().getName());
- }
- session.getTransaction().commit();
- session.close();
- }
- //解决1+N 问题 第二种方法@BatchSize(size=5)//加载Category的时候一次性加载5条public class Category {}
- @Test
- public void testQuery3() {
- Session session = sf.openSession();
- session.beginTransaction();
- List<Topic> topics = (List<Topic>)session.createQuery("from Topic").list();
- for(Topic t : topics) {
- System.out.println(t.getId() + "--" + t.getTitle());
- System.out.println(t.getCategory().getName());
- }
- session.getTransaction().commit();
- session.close();
- }
- //解决1+N 问题 三第种方法 join fetch
- @Test
- public void testQuery4() {
- Session session = sf.openSession();
- session.beginTransaction();
- List<Topic> topics = (List<Topic>)session.createQuery("from Topic t left join fetch t.category c").list();
- for(Topic t : topics) {
- System.out.println(t.getId() + "--" + t.getTitle());
- System.out.println(t.getCategory().getName());
- }
- session.getTransaction().commit();
- session.close();
- }
- public static void main(String[] args) {
- beforClass();
- }
- }
缓存
在内存里开辟一块空间，把本来应该存储在硬盘上的东西，然后放在内存里，将来再读的时候直接从内存读，这部分内存就叫缓存.
could not instantiate RegionFactory [org.hibernate.cache.impl.bridge.RegionFactoryCacheProviderBridge] EhCache的jar包 ehcache-1.2.3.jar
org/apache/commons/logging/LogFactory EhCache的jar包commons-logging-1.1.1.jar
二级缓存
- hibernate.cfg.xml 里面配置
- <property name="hibernate.cache.use_second_level_cache">true</property>
- <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
- 二级缓存范围
- @Cache(usage = CacheConcurrencyStrategy.READ_WRITE) //常用方式
- public class Category { }
查询缓存
查询缓存（2个语句一样）---重复查询才会使用缓存，2个查询不一样一定用不了，没有相应的算法能够实现
- 查询缓存的配置和使用：
- * 在hibernate.cfg.xml文件中启用查询缓存，如：
- <property name="hibernate.cache.use_query_cache">true</property>
- * 在程序中必须手动启用查询缓存，如：
- query.setCacheable(true);
查询缓存一定是依赖二级缓存的，所以要先打开二级缓存，再打开查询缓存
如何证明查询缓存起作用，发2条相同的list 如果不出现2条sql 语句即可证明
缓存算法： 内存的对象一旦满了之后，新来的对象要把原来的对象给替换掉，满了之后的对象先完蛋.
- </pre><pre name="code" class="java">package com.demo.hibernate;
- import java.util.Date;
- import java.util.Iterator;
- import java.util.List;
- import javax.persistence.FetchType;
- import javax.persistence.ManyToOne;
- import org.hibernate.Criteria;
- import org.hibernate.Session;
- import org.hibernate.SessionFactory;
- import org.hibernate.annotations.BatchSize;
- import org.hibernate.cfg.AnnotationConfiguration;
- import org.hibernate.criterion.Example;
- import org.hibernate.criterion.Restrictions;
- import org.hibernate.tool.hbm2ddl.SchemaExport;
- import org.junit.AfterClass;
- import org.junit.BeforeClass;
- import org.junit.Test;
- public class HibernateCacheTest {
- private static SessionFactory sf = null;
- @BeforeClass
- public static void beforClass() {
- // new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- try {
- sf = new AnnotationConfiguration().configure().buildSessionFactory();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @AfterClass
- public static void afterClass() {
- sf.close();
- }
- @Test
- public void testSchemaExport() { //生成建表语句
- new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- }
- @Test
- public void testSave() {
- Session session = sf.openSession();
- session.beginTransaction();
- // 存入10个板块
- for(int i=0; i<10; i++) {
- Category c = new Category();
- c.setName("c"+i);
- Topic t = new Topic();
- t.setCategory(c);
- t.setCreateDate(new Date());
- t.setTitle("t" + i);
- session.save(c);
- session.save(t);
- }
- session.getTransaction().commit();
- session.close();
- }
- @Test
- public void testCache1() {
- Session session = sf.openSession();
- session.beginTransaction();
- Category c = (Category)session.load(Category.class, 1);
- System.out.println(c.getName());
- Category c1 = (Category)session.load(Category.class, 1);
- System.out.println(c1.getName());
- // 只发一条sql语句 ，因为session 有缓存
- session.getTransaction().commit();
- session.close();
- }
- // 证明一个session 是不能去取另外一个session 的缓存的 利用二级缓存可以解决此问题
- @Test
- public void testCache2() {
- Session session = sf.openSession();
- session.beginTransaction();
- Category c = (Category)session.load(Category.class, 1);
- System.out.println(c.getName());
- session.getTransaction().commit();
- session.close();
- Session session1 = sf.openSession();
- session1.beginTransaction();
- Category c1 = (Category)session1.load(Category.class, 1);
- System.out.println("-----" + c1.getName());
- session1.getTransaction().commit();
- session1.close();
- }
- //证明查询缓存起作用
- @Test
- public void testQueryCache() {
- Session session = sf.openSession();
- session.beginTransaction();
- List<Category> categories1 = (List<Category>)session.createQuery("from Category").setCacheable(true).list();
- List<Category> categories2 = (List<Category>)session.createQuery("from Category").setCacheable(true).list();
- session.getTransaction().commit();
- session.close();
- }
- public static void main(String[] args) {
- beforClass();
- }
- }
第25课 事务并发处理
一、 数据库的隔离级别：并发性作用。
1、 ReadUncommited(未提交读):没有提交就可以读取到数据（发出了Insert，但没有commit就可以读取到。）很少用
2、 ReadCommited(提交读):只有提交后才可以读，常用，
3、 RepeatableRead(可重复读):mysql默认级别, 必需提交才能见到，读取数据时数据被锁住。
4、 Serialiazble(序列化读):最高隔离级别，串型的，你操作完了，我才可以操作，并发性特别不好，
| 隔离级别 |
是否存在脏读 |
是否存在不可重复读 |
是否存在幻读 |
| Read Uncommitted(未提交读) |
Y |
Y |
Y |
| Read Commited(提交读) |
N |
Y(可采用悲观锁解决) |
Y |
| Repeatable Read(可重复读) |
N |
N |
Y |
| Serialiazble(序列化读) |
|
|
|
脏读：没有提交就可以读取到数据称为脏读
不可重复读：再重复读一次，数据与你上读取的不一样。称不可重复读。
幻读：在查询某一条件的数据，开始查询的后，别人又加入或删除些数据，再读取时与原来的数据不一样了。
1、 Mysql查看数据库隔离级别：
方法：select@@tx_isolation;
2、 Mysql数据库修改隔离级别：
方法：set transactionisolation level 隔离级别名称;
例如：修改为未提交读：settransaction isolation level read uncommitted;
二、 事务概念(ACID)
ACID即：事务的原子性、一致性、独立性及持久性
事务的原子性:是指一个事务要么全部执行,要么不执行.也就是说一个事务不可能只执行了一半就停止了.比如你从取款机取钱,这个事务可以分成两个步骤:1划卡,2出钱.不可能划了卡,而钱却没出来.这两步必须同时完成.要么就不完成.
事务的一致性:是指事务的运行并不改变数据库中数据的一致性.例如,完整性约束了a+b=10,一个事务改变了a,那么b也应该随之改变.
事务的独立性:是指两个以上的事务不会出现交错执行的状态.因为这样可能会导致数据不一致.
事务的持久性:是指事务运行成功以后,就系统的更新是永久的.不会无缘无故的回滚.
三、 事务并发时可能出现问题
1、第一类丢失更新(Lost Update)
| 时间 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
第26课 hibernate悲观锁、乐观锁
Hibernate谈到悲观锁、乐观锁，就要谈到数据库的并发问题，数据库的隔离级别越高它的并发性就越差
并发性：当前系统进行了序列化后，当前读取数据后，别人查询不了，看不了。称为并发性不好
数据库隔离级别：见前面章级
一、 悲观锁
悲观锁：具有排他性(我锁住当前数据后，别人看到不此数据)
悲观锁一般由数据机制来做到的。
1、 悲观锁的实现
通常依赖于数据库机制，在整修过程中将数据锁定，其它任何用户都不能读取或修改(如：必需我修改完之后，别人才可以修改)
2、 悲观锁的适用场景：
悲观锁一般适合短事务比较多(如某一数据取出后加1，立即释放)
长事务占有时间(如果占有1个小时，那么这个1小时别人就不可以使用这些数据)，不常用。
3、 实例：
用户1、用户2 同时读取到数据，但是用户2先 －200，这时数据库里的是800，现在用户1也开始－200，可是用户1刚才读取到的数据是1000，现在用户用刚刚一开始读取的数据1000－200为800，而用户1在更新时数据库里的是用房更新的数据800，按理说用户1应该是800－200＝600，而现在是800，这样就造成的更新丢失。这种情况该如何处理呢，可采用两种方法：悲观锁、乐观锁。先看看悲观锁：用户1读取数据后，用锁将其读取的数据锁上，这时用户2是读取不到数据的，只有用户1释放锁后用户2才可以读取，同样用户2读取数据也锁上。这样就可以解决更新丢失的问题了。
实体类：
public class Inventory {
private int itemNo;
privateString itemName;
private int quantity;
public intgetItemNo() {
return itemNo;
}
public voidsetItemNo(intitemNo) {
this.itemNo =itemNo;
}
publicString getItemName() {
return itemName;
}
public voidsetItemName(String itemName) {
this.itemName =itemName;
}
public intgetQuantity() {
return quantity;
}
public voidsetQuantity(intquantity) {
this.quantity =quantity;
}
}
映射文件：
<hibernate-mapping>
<class name="com.wjt276.hibernate.Inventory"table="t_inventory">
<id name="itemNo">
<generator class="native"/>
</id>
<property name="itemName"/>
<property name="quantity"/>
</class>
</hibernate-mapping>
4、 悲观锁的使用
如果需要使用悲观锁，肯定在加载数据时就要锁住，通常采用数据库的for update语句。
Hibernate使用Load进行悲观锁加载。
Session.load(Classarg0, Serializable arg1, LockMode arg2) throws HibernateException
LockMode：悲观锁模式（一般使用LockMode.UPGRADE）
session= HibernateUtils.getSession();
tx = session.beginTransaction();
Inventory inv =(Inventory)session.load(Inventory.class, 1,LockMode.UPGRADE);
System.out.println(inv.getItemName());
inv.setQuantity(inv.getQuantity()-200);
session.update(inv);
tx.commit();
5、 执行输出SQL语句：
Hibernate:select inventory0_.itemNo as itemNo0_0_, inventory0_.itemName as itemName0_0_,inventory0_.quantity as quantity0_0_ from t_inventory inventory0_ whereinventory0_.itemNo=? for update //在select语句中加入for update进行使用悲观锁。
脑白金
Hibernate:update t_inventory set itemName=?, quantity=? where itemNo=?
注：只有用户释放锁后，别的用户才可以读取
注：如果使用悲观锁，那么lazy(悚加载无效)
二、 乐观锁
乐观锁：不是锁，是一种冲突检测机制。
乐观锁的并发性较好，因为我改的时候，别人随边修改。
乐观锁的实现方式：常用的是版本的方式（每个数据表中有一个版本字段version，某一个用户更新数据后，版本号＋1，另一个用户修改后再＋1，当用户更新发现数据库当前版本号与读取数据时版本号不一致(等于小于数据库当前版本号)，则更新不了。
Hibernate使用乐观锁需要在映射文件中配置项才可生效。
实体类：
public classInventory {
private int itemNo;
privateString itemName;
private int quantity;
private int version;//Hibernate用户实现版本方式乐观锁，但需要在映射文件中配置
public intgetItemNo() {
return itemNo;
}
public voidsetItemNo(intitemNo) {
this.itemNo =itemNo;
}
publicString getItemName() {
return itemName;
}
public voidsetItemName(String itemName) {
this.itemName =itemName;
}
public intgetQuantity() {
return quantity;
}
public voidsetQuantity(intquantity) {
this.quantity =quantity;
}
public intgetVersion() {
return version;
}
public voidsetVersion(intversion) {
this.version =version;
}
}
映射文件
<hibernate-mapping>
<!-- 映射实体类时，需要加入一个开启乐观锁的属性
optimistic-lock="version" 共有好几种方式：
- none -version - dirty - all
同时需要在主键映射后面映射版本号字段
-->
<class name="com.wjt276.hibernate.Inventory"table="t_inventory"optimistic-lock="version">
<id name="itemNo">
<generator class="native"/>
</id>
<version name="version"/><!—必需配置在主键映射后面 -->
<property name="itemName"/>
<property name="quantity"/>
</class>
</hibernate-mapping>
导出输出SQL语句：
createtable t_inventory (itemNo integer not null auto_increment, versioninteger not null, itemName varchar(255), quantity integer,primary key (itemNo))
注：添加的版本字段version，还是我们来维护的，是由hibernate来维护的。
乐观锁在存储数据时不用关心
_____________________________________________________________________
脏读：没有提交就可以读取到数据称为脏读
不可重复读：再重复读一次，数据与你上读取的不一样。称不可重复读。
幻读：在查询某一条件的数据，开始查询的后，别人又加入或删除些数据，再读取时与原来的数据不一样了。
- static int TRANSACTION_NONE
- 指示事务不受支持的常量。
- static int TRANSACTION_READ_COMMITTED 2
- 指示防止发生脏读的常量；不可重复读和虚读有可能发生。
- static int TRANSACTION_READ_UNCOMMITTED 1
- 指示可以发生脏读 (dirty read)、不可重复读和虚读 (phantom read) 的常量。
- static int TRANSACTION_REPEATABLE_READ 3
- 指示防止发生脏读和不可重复读的常量；虚读有可能发生。
- static int TRANSACTION_SERIALIZABLE 4
- 指示防止发生脏读、不可重复读和虚读的常量。
hibernate.connection.isolation = 2
e.g. 1, 2, 4, 8 （二进制效率）
悲观锁
- package com.demo.hibernate;
- import javax.persistence.Entity;
- import javax.persistence.GeneratedValue;
- import javax.persistence.Id;
- @Entity
- public class Account {
- private int id;
- private int balance; //BigDecimal 银行程序(精度)
- @Id
- @GeneratedValue
- public int getId() {
- return id;
- }
- public void setId(int id) {
- this.id = id;
- }
- public int getBalance() {
- return balance;
- }
- public void setBalance(int balance) {
- this.balance = balance;
- }
- }
- package com.demo.hibernate;
- import org.hibernate.LockMode;
- import org.hibernate.Session;
- import org.hibernate.SessionFactory;
- import org.hibernate.cfg.AnnotationConfiguration;
- import org.hibernate.tool.hbm2ddl.SchemaExport;
- import org.junit.AfterClass;
- import org.junit.BeforeClass;
- import org.junit.Test;
- public class HibernateCacheTest {
- private static SessionFactory sf = null;
- @BeforeClass
- public static void beforClass() {
- // new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- try {
- sf = new AnnotationConfiguration().configure().buildSessionFactory();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @AfterClass
- public static void afterClass() {
- sf.close();
- }
- @Test
- public void testSchemaExport() { //生成建表语句
- new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- }
- @Test
- public void testSave() {
- Session session = sf.openSession();
- session.beginTransaction();
- Account a = new Account();
- a.setBalance(100);
- session.save(a);
- session.getTransaction().commit();
- session.close();
- }
- @Test
- public void testOperation1() {
- Session session = sf.openSession();
- session.beginTransaction();
- Account a = (Account)session.load(Account.class, 1);
- int balance = a.getBalance();
- //do some caculations
- balance = balance - 10;
- a.setBalance(balance);
- session.getTransaction().commit();
- session.close();
- }
- @Test
- public void testPessimisticLock() {
- Session session = sf.openSession();
- session.beginTransaction();
- //LockMode.UPGRADE 就是读取这条记录的时候请数据库在我读取的时候加把锁，在这个事物没有提交之前不会有人更新它,所以叫做悲观锁
- Account a = (Account)session.load(Account.class, 1, LockMode.UPGRADE);
- int balance = a.getBalance();
- //do some caculation
- balance = balance - 10;
- a.setBalance(balance);
- session.getTransaction().commit();
- session.close();
- }
- public static void main(String[] args) {
- beforClass();
- }
- }
乐观锁
- package com.demo.hibernate;
- import javax.persistence.Entity;
- import javax.persistence.GeneratedValue;
- import javax.persistence.Id;
- import javax.persistence.Version;
- @Entity
- public class Account {
- private int id;
- private int balance; //BigDecimal 银行程序(精度)
- private int version;
- @Version //版本的问题
- public int getVersion() {
- return version;
- }
- public void setVersion(int version) {
- this.version = version;
- }
- @Id
- @GeneratedValue
- public int getId() {
- return id;
- }
- public void setId(int id) {
- this.id = id;
- }
- public int getBalance() {
- return balance;
- }
- public void setBalance(int balance) {
- this.balance = balance;
- }
- }
- package com.demo.hibernate;
- import org.hibernate.LockMode;
- import org.hibernate.Session;
- import org.hibernate.SessionFactory;
- import org.hibernate.cfg.AnnotationConfiguration;
- import org.hibernate.tool.hbm2ddl.SchemaExport;
- import org.junit.AfterClass;
- import org.junit.BeforeClass;
- import org.junit.Test;
- public class HibernateCacheTest {
- private static SessionFactory sf = null;
- @BeforeClass
- public static void beforClass() {
- // new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- try {
- sf = new AnnotationConfiguration().configure().buildSessionFactory();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @AfterClass
- public static void afterClass() {
- sf.close();
- }
- @Test
- public void testSchemaExport() { //生成建表语句
- new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); //自动创建SQL语句
- }
- @Test
- public void testSave() {
- Session session = sf.openSession();
- session.beginTransaction();
- Account a = new Account();
- a.setBalance(100);
- session.save(a);
- session.getTransaction().commit();
- session.close();
- }
- @Test
- public void testOptimisticLock() {
- Session session = sf.openSession();
- Session session2 = sf.openSession();
- session.beginTransaction();
- Account a1 = (Account) session.load(Account.class, 1);
- session2.beginTransaction();
- Account a2 = (Account) session2.load(Account.class, 1);
- a1.setBalance(900);
- a2.setBalance(1100);
- session.getTransaction().commit();
- System.out.println(a1.getVersion());
- session2.getTransaction().commit();
- System.out.println(a2.getVersion());
- session.close();
- session2.close();
- }
- public static void main(String[] args) {
- beforClass();
- }
- }