悲观锁的实现
:悲观锁依赖于数据库机制,在整个过程中将数据锁定,其他任何人都不能读取或修改
乐观锁:
大多数基于数据版本记录机制(Version)的实现,一般是在数据库表中加入一个version字段,还有时间戳等机制
读取数据时将版本一同读出,之后更新数据时版本号加1,如果提交数据时版本号小于或者等于数据库中的版本号
则认为数据是过期的否则给予更新
下面我们举例说明:
当我们采用乐观锁时映射文件:
我们运行如下2个单元测试:
testLoad1();
testLoad2()
我们用debug方法testLoad1()的方法执行时 我们让方法执行到(1)(断点一定要设置它的前面)处停止下来,我们在来运行testLoad2() 我们会发现 在加载了对象之后,也就是
执行了查询sql语句之后会停下来;当我们运行完testLoad1()之后,也就是提交了事务,解除了悲观锁之后testLoad2()才能继续运行。
乐观锁:
我们来用数据版本来实现乐观锁
我们来看Inventory的生命
映射文件
生成的数据库表中
[img]/upload/attachment/51000/03f3e4c5-7670-3906-8b3e-123137ea84f6.bmp[/img]
我们在来运行如下的单元测试:
差点忘了,在悲观锁和乐观锁的测试运行之前一定要初始化数据
舒适化数据类如下
通过以上的测试 我们可以对Hibernate悲观锁和乐观锁有个比较清晰的认识!!!
:悲观锁依赖于数据库机制,在整个过程中将数据锁定,其他任何人都不能读取或修改
乐观锁:
大多数基于数据版本记录机制(Version)的实现,一般是在数据库表中加入一个version字段,还有时间戳等机制
读取数据时将版本一同读出,之后更新数据时版本号加1,如果提交数据时版本号小于或者等于数据库中的版本号
则认为数据是过期的否则给予更新
下面我们举例说明:
package com.june.hibernate;
public class Inventory {
public Integer itemNo; //物料编号
public String itemName;//物料名称
public int quantity; //数量
........//get/set方法省略
}
当我们采用乐观锁时映射文件:
<class name="com.june.hibernate.Inventory" table="t_inventory">
<id name="itemNo">
<generator class="native" ></generator>
</id>
<property name="itemName" length="32" />
<property name="quantity"></property>
</class>
我们运行如下2个单元测试:
testLoad1();
public void testLoad1(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Inventory inventory=(Inventory)session.load(Inventory.class,2,LockMode.UPGRADE);
System.out.println("@inventory.id="+inventory.getItemNo());
System.out.println("@inventory.itemName="+inventory.getItemName());
System.out.println("@inventory.quantity="+inventory.getQuantity());
System.out.println("@提货减去200...............");
inventory.setQuantity(inventory.getQuantity()-200);//(1)
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
testLoad2()
public void testLoad2(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Inventory inventory=(Inventory)session.load(Inventory.class,2,LockMode.UPGRADE);
System.out.println("#inventory.id="+inventory.getItemNo());
System.out.println("#inventory.itemName="+inventory.getItemName());
System.out.println("#inventory.quantity="+inventory.getQuantity());
System.out.println("#提货减去200...............");
inventory.setQuantity(inventory.getQuantity()-200);
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
}
我们用debug方法testLoad1()的方法执行时 我们让方法执行到(1)(断点一定要设置它的前面)处停止下来,我们在来运行testLoad2() 我们会发现 在加载了对象之后,也就是
执行了查询sql语句之后会停下来;当我们运行完testLoad1()之后,也就是提交了事务,解除了悲观锁之后testLoad2()才能继续运行。
乐观锁:
我们来用数据版本来实现乐观锁
我们来看Inventory的生命
package com.june.hibernate;
public class Inventory {
public Integer itemNo;
public String itemName;
public int quantity;
public Integer version;
..............
}
映射文件
<class name="com.june.hibernate.Inventory"table="t_inventory" optimistic-lock="version">
<id name="itemNo">
<generator class="native" ></generator>
</id>
<!-- version一定要紧挨着Id-->
<version name="version"></version>
<property name="itemName" length="32" />
<property name="quantity"></property>
</class>
生成的数据库表中
[img]/upload/attachment/51000/03f3e4c5-7670-3906-8b3e-123137ea84f6.bmp[/img]
我们在来运行如下的单元测试:
/**
* testLoad2()
*/
public void testLoad1(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Inventory inventory=(Inventory)session.load(Inventory.class,1);
System.out.println("@inventory.id="+inventory.getItemNo());
System.out.println("@inventory.itemName="+inventory.getItemName());
System.out.println("@inventory.quantity="+inventory.getQuantity());
System.out.println("@inventroy.version="+inventory.getVersion());
System.out.println("@提货减去200...............");
inventory.setQuantity(inventory.getQuantity()-200);
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* testLoad2()
*/
public void testLoad2(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Inventory inventory=(Inventory)session.load(Inventory.class,1);
System.out.println("#inventory.id="+inventory.getItemNo());
System.out.println("#inventory.itemName="+inventory.getItemName());
System.out.println("#inventory.quantity="+inventory.getQuantity());
System.out.println("#提货减去200...............");
inventory.setQuantity(inventory.getQuantity()-200);
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
差点忘了,在悲观锁和乐观锁的测试运行之前一定要初始化数据
舒适化数据类如下
import org.hibernate.Session;
import org.hibernate.Transaction;
public class InitialData {
public static void main(String args[]){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Inventory inventory=new Inventory();
inventory.setItemName("Viager");
inventory.setQuantity(1000);
session.save(inventory);
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
}
通过以上的测试 我们可以对Hibernate悲观锁和乐观锁有个比较清晰的认识!!!